AbstractQueuedSynchronizer源码解析

static final class Node {       
     volatile int waitStatus;       
     volatile Node prev;//前驱节点
     volatile Node next; //后继节点    
     volatile Thread thread; //进入队列的当前线程      
     Node nextWaiter;//存储condition队列中的后继节点
}    

    
　　　/** waitStatus value to indicate thread has cancelled */
　　　static final int CANCELLED =  1; //当前线程被取消
    /** waitStatus value to indicate successor‘s thread needs unparking */
    static final int SIGNAL    = -1;//当前节点的后继节点需要运行
    /** waitStatus value to indicate thread is waiting on condition */
    static final int CONDITION = -2; //当前节点在等待condition
    /**
    * waitStatus value to indicate the next acquireShared should
    * unconditionally propagate
    */
    static final int PROPAGATE = -3; //当前场景下后续的acquireShared可以执行
    /** Marker to indicate a node is waiting in shared mode */
    static final Node SHARED = new Node();
    /** Marker to indicate a node is waiting in exclusive mode */
    static final Node EXCLUSIVE = null;  //当前场景下后续的acquireShared可以执行      

    private transient volatile Node head;  
    private transient volatile Node tail;
    private volatile int state;

　　　/**
     * CAS tail field. Used only by enq
     */
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

　　 　
　　　//独占式获取同步状态，该方法的实现需要先查询当前的同步状态是否可以获取，如果可以获取再进行获取；
　　　protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
　   //释放状态;
　　 protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
　　 //共享式获取同步状态；
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
    //共享式释放状态;    
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
    //独占模式下，判断同步状态是否已经被占用;
    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

　　private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

　　private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                Node h = new Node(); // Dummy header
                h.next = node;
                node.prev = h;
                if (compareAndSetHead(h)) {
                    tail = node;
                    return h;
                }
            }
            else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
}

　　private void doReleaseShared() {
         for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue; // loop to recheck cases
                    unparkSuccessor(h);
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue; // loop on failed CAS
            }
            if (h == head) // loop if head changed
                break;
        }
    }

　　public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }