chapter15_原子变量与非阻塞同步机制_4_非阻塞算法

• 原子变量的compareAndSet操作__既能提供原子性, 又能提供可见性__

    public class AtomicInteger extends Number implements java.io.Serializable {
  
        ...
  
        private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
  
        ...
  
        public final int incrementAndGet() {
            return U.getAndAddInt(this, VALUE, 1) + 1;
        }
  
        ...
    }
  
    public final class Unsafe {
  
        ...
  
        @HotSpotIntrinsicCandidate
        public final int getAndAddInt(Object o, long offset, int delta) {
  
            int v;
  
            do {
                v = getIntVolatile(o, offset);
            } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    
            return v;
        }
  
        ...
    }
  

• 非阻塞计数器

    @ThreadSafe
    public class CasCounter {
  
        private SimulatedCAS value;
  
        public int getValue() {
  
            return value.get();
        }
  
        public int increment() {
  
            int v;
    
            do {
                v = value.get();
            } while (v != value.compareAndSwap(v, v + 1));
  
            return v + 1;
        }
    }
  

• 非阻塞的栈

    @ThreadSafe
    public class ConcurrentStack<E> {
  
        private AtomicReference<Node<E>> top = new AtomicReference<Node<E>>();
  
        public void push(E item) {
  
            Node<E> newHead = new Node<>(item);
            Node<E> oldHead;
    
            do {
                oldHead = top.get();
                newHead.next = oldHead;
            } while (!top.compareAndSet(oldHead, newHead));
        }
  
        public E pop() {
    
            Node<E> oldHead;
            Node<E> 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<E> {
  
            public final E item;
            public Node<E> next;
  
            public Node(E item) {
  
                this.item = item;
            }
        }
    }
  

• CAS的基本使用模式是

  在更新某个值时存在不确定性, 在更新失败时重新尝试