非阻塞同步算法

Treiber 1986

栈顶为一序列

public class ConcurrentStack<E> {
	AtomicReference<Node<E>> top = new AtomicReference<Node<E>>();
	
	public void push(E item){
		Node<E> newHead = new Node<E>(item);
		Node<E> oldHead = null;
		do{
			oldHead = top.get();
			newHead.next = oldHead;
		}while(!top.compareAndSet(oldHead, newHead));
	}
	
	public E pop(){
		Node<E> newHead = null;
		Node<E> oldHead = null;
		do{
			oldHead = top.get();
			if(oldHead == null){
				return null;
			}
			newHead = oldHead.next;
		}while(!top.compareAndSet(oldHead, newHead));
		return oldHead.item;
	}
	
	private static class Node<E>{
		public final E item;
		public Node<E> next;
		public Node(E item){
			this.item = item;
		}
	}
}

Michael Scott 1996

队尾和尾部节点两个序列

public class ConcurrentLink<E> {

	private final Node<E> dummy = new Node<E>(null, null);

	private final AtomicReference<Node<E>> head = 
		new AtomicReference<Node<E>>(dummy);
	private final AtomicReference<Node<E>> tail = 
		new AtomicReference<Node<E>>(dummy);
	
	public boolean push(E item){
		Node<E> newNode = new Node<E>(item, null);
		while(true){
			Node<E> curTail = tail.get();
			Node<E> tailNext = curTail.next.get();
			if(curTail == tail.get()){
				if(tailNext != null){
					tail.compareAndSet(curTail, tailNext);
				}else{
					if(curTail.next.compareAndSet(null, newNode)){
						tail.compareAndSet(curTail, newNode);
						return true;
					}
				}
			}
		}
	}
	
	private static class Node<E>{
		final E item;
		final AtomicReference<Node<E>> next;
		
		public Node(E item, Node<E> next){
			this.item = item;
			this.next = new AtomicReference<Node<E>>(next);
		}
	}
	
}