Java 高并发容器设计要点

public class ConcurrentStack {
    
     AtomicReference> top = new AtomicReference>();

     public void push(E item) {
         Node newHead = new Node(item);
         Node oldHead;
         do {
             oldHead = top.get();
             newHead.next = oldHead;
         } while (!top.compareAndSet(oldHead, newHead));
     }

     public E pop() {
         Node oldHead;
         Node newHead;
         do {
             oldHead = top.get();
             if (oldHead == null)
                 return null;
             newHead = oldHead.next;
         } while (!top.compareAndSet(oldHead, newHead));
         return oldHead.item;
    }

 private static class Node {
    public final E item;
    public Node next;
    public Node(E item) {
        this.item = item;
    }
}
}

public class ConcurrentLinkedQueue {
private static class Node {
    final E item;
    final AtomicReference> next;
    public Node(E item, Node next) {
        this.item = item;
        this.next = new AtomicReference>(next);
    }
   private final Node dummy = new Node(null, null);
   private final AtomicReference> head = new AtomicReference>(dummy);
   private final AtomicReference> tail = new AtomicReference>(dummy);}
   public boolean put(E item) {
    Node newNode = new Node(item, null);
    while (true) {
             Node curTail = tail.get();
             Node tailNext = curTail.next.get();
             if (curTail == tail.get()) {
                 if (tailNext != null) {
                     // Queue in intermediate state, advance tail
                     tail.compareAndSet(curTail, tailNext);
                 } else {
                     // In quiescent state, try inserting new node
                     if (curTail.next.compareAndSet(null, newNode)) {
                         // Insertion succeeded, try advancing tail
                         tail.compareAndSet(curTail, newNode);
                         return true;
                    }
                 }
            }
    }
}