// 內(nèi)部類Node節(jié)點(diǎn)static final class Node{...}// 同步隊(duì)列的head引用private transient volatile Node head;// 同步隊(duì)列的tail引用private transient volatile Node tail;

    static final class Node {/** 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;/** 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;/** * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate         */static final int PROPAGATE = -3;/** 等待狀態(tài)：
         * 0 INITAIL： 初始狀態(tài)
         * 1 CANCELLED: 由于等待超時(shí)或者被中斷，需要從同步隊(duì)列中取消等待，節(jié)點(diǎn)進(jìn)入該狀態(tài)不會(huì)被改變
         * -1 SIGNAL: 當(dāng)前節(jié)點(diǎn)釋放同步狀態(tài)或被取消，則等待狀態(tài)的后繼節(jié)點(diǎn)被通知
         * -2 CONDITION: 節(jié)點(diǎn)在等待隊(duì)列中，線程在Condition上，需要其它線程調(diào)用Condition的signal()方法才能從等待隊(duì)轉(zhuǎn)移到同步隊(duì)列
         * -3 PROPAGATE: 表示下一個(gè)共享式同步狀態(tài)將會(huì)無條件被傳播下去         */volatile int waitStatus;/** 前驅(qū)結(jié)點(diǎn) */volatile Node prev;/** 后繼節(jié)點(diǎn) */volatile Node next; /** 獲取同步狀態(tài)的線程 */volatile Thread thread;/** 等待隊(duì)列中的后繼節(jié)點(diǎn) */Node nextWaiter;      /** 判斷Node是否是共享模式 */final boolean isShared() {return nextWaiter == SHARED;
        } /** 返回前驅(qū)結(jié)點(diǎn) */final Node predecessor() throws NullPointerException {
            Node p = prev;if (p == null)throw new NullPointerException();elsereturn p;
        }

        Node() {    // Used to establish initial head or SHARED marker        }

        Node(Thread thread, Node mode) {     // Used by addWaiterthis.nextWaiter = mode;this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Conditionthis.waitStatus = waitStatus;this.thread = thread;
        }
    }

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

 private Node addWaiter(Node mode) {// 根據(jù)給定模式構(gòu)造NodeNode node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail; // 嘗試在尾部添加if (pred != null) {
            node.prev = pred;// cas方式保證正確添加尾節(jié)點(diǎn)if (compareAndSetTail(pred, node)) {
                pred.next = node;return node;
            }
        }// enq主要是通過for(;;)死循環(huán)來確保節(jié)點(diǎn)正確添加// 在for(;;)死循環(huán)中，通過cas將節(jié)點(diǎn)設(shè)置為尾節(jié)點(diǎn)時(shí)，才返回；否則一直嘗試設(shè)置        enq(node);return node;
    } private Node enq(final Node node) {for (;;) {
            Node t = tail;if (t == null) { // Must initialize  當(dāng)tail節(jié)點(diǎn)為null時(shí)，必須初始化構(gòu)造好    head節(jié)點(diǎn)if (compareAndSetHead(new Node()))
                    tail = head;
            } else { // 否則就通過cas開始添加尾節(jié)點(diǎn)node.prev = t;if (compareAndSetTail(t, node)) {
                    t.next = node;return t;
                }
            }
        }
    }

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();// 當(dāng)前node節(jié)點(diǎn)的前驅(qū)是Head時(shí)（p == head），才能有資格去嘗試獲取同步狀態(tài)（tryAcquire(arg)）// 這是因?yàn)楫?dāng)前節(jié)點(diǎn)的前驅(qū)結(jié)點(diǎn)獲得同步狀態(tài)，才能喚醒后繼節(jié)點(diǎn)，即當(dāng)前節(jié)點(diǎn)if (p == head && tryAcquire(arg)) { // 以上條件滿足之后setHead(node); // 設(shè)置當(dāng)前節(jié)點(diǎn)為Headp.next = null; // help GC // 釋放ndoe的前驅(qū)節(jié)點(diǎn)failed = false;return interrupted;
                }// 線程被中斷或者前驅(qū)結(jié)點(diǎn)被釋放，則繼續(xù)進(jìn)入檢查：p == head && tryAcquire(argif (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {if (failed)
                cancelAcquire(node);
        }
    }

    public final boolean release(int arg) {if (tryRelease(arg)) {
            Node h = head;if (h != null && h.waitStatus != 0)// 該方法會(huì)喚醒Head節(jié)點(diǎn)的后繼節(jié)點(diǎn)，使其重試嘗試獲取同步狀態(tài)                unparkSuccessor(h);return true;
        }return false;
    }

    public final void acquireShared(int arg) {// tryAcquireShared 獲取同步狀態(tài)，大于0才是獲取狀態(tài)成功，否則就是失敗if (tryAcquireShared(arg) < 0)// 獲取狀態(tài)失敗則構(gòu)造共享Node，加入隊(duì)列；// 并且檢查是否具備退出自旋的條件：即preNode為head，并且能獲取到同步狀態(tài)            doAcquireShared(arg);
    }

private void doAcquireShared(int arg) {// 構(gòu)造共享模式的Nodefinal Node node = addWaiter(Node.SHARED);boolean failed = true;try {boolean interrupted = false;for (;;) {final Node p = node.predecessor();if (p == head) {int r = tryAcquireShared(arg);// 前驅(qū)節(jié)點(diǎn)是頭結(jié)點(diǎn)，并且能獲取狀態(tài)成功，則return返回，退出死循環(huán)（自旋）if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GCif (interrupted)
                            selfInterrupt();
                        failed = false;return;
                    }
                }if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {if (failed)
                cancelAcquire(node);
        }
    }

    public final boolean releaseShared(int arg) {if (tryReleaseShared(arg)) {// 通過loop+CAS方式釋放多個(gè)線程的同步狀態(tài)            doReleaseShared();return true;
        }return false;
    }