柳絲榆莢自芳菲工坊，不管桃飄與李飛。

前言

AQS內(nèi)部維持著一個(gè)雙向的同步隊(duì)列沛鸵，節(jié)點(diǎn)狀態(tài)可以是共享的也可以是獨(dú)占的制轰。

構(gòu)造函數(shù)

//構(gòu)造函數(shù)為protected，只有子類或者同包下的類才能訪問(wèn)均澳。 
protected AbstractQueuedSynchronizer() { }

屬性和靜態(tài)代碼塊

//同步隊(duì)列的首結(jié)點(diǎn)恨溜，延遲初始化。除了初始化之外找前，它只通過(guò)setHead方法進(jìn)行修改糟袁。
//注意:如果head存在，則保證它的status不為cancelled
private transient volatile Node head;

//同步隊(duì)列的尾結(jié)點(diǎn)躺盛，延遲初始化项戴。只有通過(guò)enq加入新的節(jié)點(diǎn)時(shí)，才會(huì)被修改槽惫。
private transient volatile Node tail;

// 同步狀態(tài)
private volatile int state;

//快速自旋的時(shí)間（單位：納秒）周叮，而不是park線程的時(shí)間。
//為了提高在短時(shí)間內(nèi)的足夠好的響應(yīng)的一個(gè)粗略估計(jì)值界斜。
static final long spinForTimeoutThreshold = 1000L;

//獲取支持compareAndSet的一些屬性
//獲取Unsafe實(shí)例
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

static {
    try {
        //獲取AbstractQueuedSynchronizer類的state字段的內(nèi)存地址偏移量
        stateOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
        //獲取AbstractQueuedSynchronizer類的head字段的內(nèi)存地址偏移量
        headOffset = unsafe.objectFieldOffset
           (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
        //獲取AbstractQueuedSynchronizer類的tail字段的內(nèi)存地址偏移量
        tailOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
        //獲取Node類的waitStatus字段的內(nèi)存地址偏移量
        waitStatusOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("waitStatus"));
        //獲取Node類的next字段的內(nèi)存地址偏移量    
        nextOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("next"));

    } catch (Exception ex) { throw new Error(ex); }
}

private方法

//將隊(duì)列頭設(shè)置為節(jié)點(diǎn)仿耽，從而退出隊(duì)列。
//只有獲取同步狀態(tài)的方法中才會(huì)調(diào)用它各薇。
//為了GC和不必要的signal和遍歷项贺，將不使用的屬性置為null。
//head節(jié)點(diǎn)只是獲得同步狀態(tài)的線程通知后繼阻塞線程的載體
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

//CAS的去設(shè)置同步隊(duì)列的head。只在enq方法中使用敬扛。
private final boolean compareAndSetHead(Node update) {
    //因?yàn)閔ead節(jié)點(diǎn)是延遲初始化的晰洒，所以剛開(kāi)始是null。
    return unsafe.compareAndSwapObject(this, headOffset, null, update);
}

//CAS的設(shè)置同步隊(duì)列的tail啥箭。只在enq方法中使用谍珊。
private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

//CAS的設(shè)置node的next屬性
private static final boolean compareAndSetNext(Node node,
                                               Node expect,
                                               Node update) {
    return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
}

//CAS的去設(shè)置Node的status屬性。
private static final boolean compareAndSetWaitStatus(Node node,
                                                     int expect,
                                                     int update) {
   //waitStatusOffset表示node對(duì)象status在內(nèi)存中的地址偏移量
    return unsafe.compareAndSwapInt(node, waitStatusOffset,
                                    expect, update);
}
//將節(jié)點(diǎn)加入到同步隊(duì)列中
//返回插入的節(jié)點(diǎn)在同步隊(duì)列中的前一個(gè)節(jié)點(diǎn)
//同步隊(duì)列是一個(gè)雙向隊(duì)列
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { 
            //因?yàn)橥疥?duì)列的首尾節(jié)點(diǎn)是是延遲初始化的急侥，
            //所以插入頭結(jié)點(diǎn)時(shí)應(yīng)該初始化砌滞。
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //建立前后節(jié)點(diǎn)間的連接
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

//構(gòu)建指定類型的節(jié)點(diǎn)并且加入到同步隊(duì)列中。
//也可以有共享模式的節(jié)點(diǎn)坏怪，并且條件隊(duì)列中的節(jié)點(diǎn)是不是也可以有這兩種狀態(tài)贝润？？
//返回一個(gè)新的節(jié)點(diǎn)
private Node addWaiter(Node mode) {
    //mode為Node.EXCLUSIVE表示為獨(dú)占模式下的節(jié)點(diǎn)铝宵，
    //為Node.SHARED表示共享模式下的節(jié)點(diǎn)打掘。
    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;
}
//從同步隊(duì)列的尾結(jié)點(diǎn)開(kāi)始自旋尋找，查看當(dāng)前節(jié)點(diǎn)是否在同步隊(duì)列中鹏秋，
//如果在同步隊(duì)隊(duì)列中尊蚁，那么返回true。
//本方法只會(huì)在isOnSyncQueue方法中調(diào)用侣夷。
private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        //表示t為頭結(jié)點(diǎn)的前一個(gè)節(jié)點(diǎn)
        //已經(jīng)遍歷到頭結(jié)點(diǎn)了横朋，還是沒(méi)有找到當(dāng)前節(jié)點(diǎn)，那么返回false
        if (t == null)
            return false;
        t = t.prev;
    }
}

//如果后繼節(jié)點(diǎn)存在百拓，則喚醒后繼節(jié)點(diǎn)琴锭。
private void unparkSuccessor(Node node) {
    //如果當(dāng)前節(jié)點(diǎn)狀態(tài)為負(fù)值（可能在等待signal）,在被signal之前，
    //將節(jié)點(diǎn)的狀態(tài)設(shè)置為0衙传。
    //如果清除狀態(tài)失敗或者在線程等待的時(shí)候决帖，狀態(tài)被其他線程改變了，
    //也沒(méi)有關(guān)系粪牲。
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    //將要unpark的線程已經(jīng)保存在后繼節(jié)點(diǎn)中古瓤，一般就是下一個(gè)節(jié)點(diǎn)。
    //但是下一個(gè)節(jié)點(diǎn)被cancelled或者為空,那么就從后向前遍歷同步隊(duì)列腺阳，
    //找到non-cancelled的后繼節(jié)點(diǎn)。
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
       //節(jié)點(diǎn)被喚醒穿香，但是還是在同步隊(duì)列中亭引，去競(jìng)爭(zhēng)同步狀態(tài)。
        LockSupport.unpark(s.thread);
}
//獲取同步狀態(tài)失敗之后皮获，檢查并更新當(dāng)前節(jié)點(diǎn)的狀態(tài)焙蚓。
//如果當(dāng)前節(jié)點(diǎn)的線程應(yīng)該阻塞，返回true。
//這個(gè)方法是循環(huán)獲取同步狀態(tài)中的主要信號(hào)控制购公。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //pre當(dāng)前節(jié)點(diǎn)的前一個(gè)持有同步狀態(tài)的節(jié)點(diǎn)
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        //這個(gè)節(jié)點(diǎn)已經(jīng)設(shè)置了前一個(gè)節(jié)點(diǎn)的狀態(tài)萌京，讓其釋放同步狀態(tài)之后喚醒它。
        //那么這個(gè)節(jié)點(diǎn)可以安全park宏浩。
        return true;
    if (ws > 0) {
        //前一個(gè)節(jié)點(diǎn)被cancelled知残，所以需要往前遍歷,
        //直到找到?jīng)]有被cancelled的節(jié)點(diǎn)。
        //（相當(dāng)于刪除隊(duì)列中取消狀態(tài)的節(jié)點(diǎn)）
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        //（因?yàn)檫@是同步隊(duì)列比庄，節(jié)點(diǎn)狀態(tài)不可能為condition）求妹。
        //那么進(jìn)入這個(gè)分支之后，當(dāng)前節(jié)點(diǎn)狀態(tài)只可能為初始化的0或者propagate佳窑。
        //前一個(gè)節(jié)點(diǎn)狀態(tài)為0或者propagate制恍，那么當(dāng)前節(jié)點(diǎn)需要signal，但是不用park神凑。
        //調(diào)用者需要重新嘗試以確保節(jié)點(diǎn)在parking之前不能去獲取同步狀態(tài)净神。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//park當(dāng)前線程，并返回線程的中斷狀態(tài)溉委。
//如果線程被中斷了强挫，那么返回true。
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    //Thread.interrupted()清除線程的中斷標(biāo)志薛躬，并返回清除之前的中斷標(biāo)志俯渤。
    return Thread.interrupted();
}

//當(dāng)fastppath失敗的時(shí)候調(diào)用芋绸，是getFirstQueuedThread的另一個(gè)版本
private Thread fullGetFirstQueuedThread() {
   //第一個(gè)節(jié)點(diǎn)通常是head.next简珠。嘗試獲取它的線程字段，確保一致讀取:如果線程為null 
   //或者s.prev不再是head咬腕，然后在我們?nèi)ト〉谝粋€(gè)線程節(jié)點(diǎn)的時(shí)候趴酣，
   //其他一些并發(fā)地執(zhí)行setHead梨树。
   //在從后遍歷之前，我們嘗試了兩次岖寞。
   /**
    *將頭結(jié)點(diǎn)賦值給h抡四，將頭結(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)賦值給s。
    *下面的檢查操作執(zhí)行了兩次
    * (
    *       (h = head) != null && (s = h.next) != null &&
    *       s.prev == head && (st = s.thread) != null
    *)
    */
    Node h, s;
    Thread st;
    if (((h = head) != null && (s = h.next) != null &&
         s.prev == head && (st = s.thread) != null) ||
        ((h = head) != null && (s = h.next) != null &&
         s.prev == head && (st = s.thread) != null))
        return st;

    //如果head的next還沒(méi)有設(shè)置仗谆，或者當(dāng)setHead之后指巡，可能head的next沒(méi)有設(shè)置。
    //所以需要檢查tail是不是第一個(gè)節(jié)點(diǎn)隶垮。如果不是藻雪，那么需要安全地從tail遍歷到head，
    //找到第一個(gè)節(jié)點(diǎn)狸吞，確保終止勉耀。
    Node t = tail;
    Thread firstThread = null;
    while (t != null && t != head) {
        Thread tt = t.thread;
        if (tt != null)
            firstThread = tt;
        t = t.prev;
    }
    return firstThread;
}

//設(shè)置同步隊(duì)列的頭結(jié)點(diǎn)指煎，檢查后繼節(jié)點(diǎn)，是不是在共享模式中便斥，
//如果是在共享模式下至壤，或者在propagate > 0或者status是propagate，
//那么傳播同步狀態(tài)枢纠。
private void setHeadAndPropagate(Node node, int propagate) {
    //node將要被設(shè)置為頭結(jié)點(diǎn)的節(jié)點(diǎn)
    //propagate是tryAcquireShared的返回值像街。
    Node h = head; // Record old head for check below
    setHead(node);
    //嘗試signal隊(duì)列的下一個(gè)節(jié)點(diǎn)：
    //1.同步狀態(tài)被調(diào)用者傳播,或者被前一個(gè)操作記錄下來(lái)
    //（在setHead的前后記錄狀態(tài)都是可以的）;
    //(對(duì)status采用符號(hào)校驗(yàn)，因?yàn)橛锌赡躶tatus從propagate轉(zhuǎn)變?yōu)閟ignal)
    //2.并且下一個(gè)等待的節(jié)點(diǎn)是同步模式京郑，
    //或者不知道處于什么狀態(tài)宅广，因?yàn)楣?jié)點(diǎn)看起來(lái)是空的。
    //只有在多個(gè)線程競(jìng)爭(zhēng)獲取/釋放同步狀態(tài)些举，這兩項(xiàng)檢查才會(huì)導(dǎo)致不必要的喚醒
    //大多數(shù)線程都需要喚醒跟狱。

    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        //這里的head已經(jīng)是新的頭結(jié)點(diǎn)了
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

//取消正在嘗試獲取同步狀態(tài)的節(jié)點(diǎn)
private void cancelAcquire(Node node) {
    if (node == null)
        return;

    node.thread = null;

    // 跳過(guò)已經(jīng)cancelled的前繼節(jié)點(diǎn)
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;
    Node predNext = pred.next;

    // 這里使用無(wú)條件寫(xiě)而不是CAS。
    //在這個(gè)原子操作之后户魏，其他線程可以跳過(guò)該節(jié)點(diǎn)驶臊。
    //在這個(gè)原子操作之前，該節(jié)點(diǎn)可以不受其他線程的干擾叼丑。
    node.waitStatus = Node.CANCELLED;

    // 如果當(dāng)前節(jié)點(diǎn)是尾結(jié)點(diǎn)关翎，那么將前繼節(jié)點(diǎn)設(shè)置為尾結(jié)點(diǎn)。
    //并將尾結(jié)點(diǎn)的下一個(gè)節(jié)點(diǎn)設(shè)置為null
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        //如果后繼節(jié)點(diǎn)需要signal鸠信，那么嘗試設(shè)置pred的next-link纵寝，讓pred有后繼者，
        //否則星立，喚醒當(dāng)前節(jié)點(diǎn),傳播同步狀態(tài)爽茴。
        int ws;
        //1.前繼節(jié)點(diǎn)不是頭結(jié)點(diǎn)；
        //2.前繼節(jié)點(diǎn)狀態(tài)為signal或者<=0并設(shè)置前繼節(jié)點(diǎn)狀態(tài)為signal成功绰垂；
        //3.前繼節(jié)點(diǎn)的線程不為空
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            //喚醒當(dāng)前節(jié)點(diǎn)的后繼節(jié)點(diǎn)
            unparkSuccessor(node);
        }
        //將當(dāng)前節(jié)點(diǎn)踢出
        node.next = node; // help GC
    }}

1.獨(dú)占模式

//獨(dú)占模式下可中斷的獲取同步狀態(tài)室奏。
private void doAcquireInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            //前繼節(jié)點(diǎn)是頭結(jié)點(diǎn)并且當(dāng)前節(jié)點(diǎn)獲取同步狀態(tài)成功
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return;
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//獨(dú)占模式下指定等待時(shí)間的獲取同步狀態(tài)
//指定時(shí)間內(nèi)，獲取同步狀態(tài)成功劲装，返回true胧沫。
private boolean doAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    final long deadline = System.nanoTime() + nanosTimeout;
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            //前繼節(jié)點(diǎn)是頭結(jié)點(diǎn)并且當(dāng)前節(jié)點(diǎn)獲取同步狀態(tài)成功
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            //剩余等待時(shí)間
            nanosTimeout = deadline - System.nanoTime();
            if (nanosTimeout <= 0L)
                return false;
            //如果當(dāng)前線程應(yīng)該阻塞，但是由于時(shí)間小于自旋超時(shí)時(shí)間占业，
            //那么不要去阻塞绒怨，直接進(jìn)行下一次自旋，獲取同步狀態(tài)纺酸。
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

2.共享模式

//共享模式下不可中斷的獲取同步狀態(tài)
private void doAcquireShared(int arg) {
    final 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);
                //獲取同步狀態(tài)成功
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}


//共享模式下可中斷的獲取同步狀態(tài)
private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//共享模式下指定時(shí)間內(nèi)獲取同步狀態(tài)
//如果指定時(shí)間內(nèi)獲取同步狀態(tài)成功窖逗，返回true。
private boolean doAcquireSharedNanos(int arg, long nanosTimeout)
        throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    final long deadline = System.nanoTime() + nanosTimeout;
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
            }
            nanosTimeout = deadline - System.nanoTime();
            if (nanosTimeout <= 0L)
                return false;
            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

//在共享模式下釋放同步狀態(tài)--喚醒后繼者并且傳播同步狀態(tài)
//注意：在獨(dú)占模式下餐蔬，如果后繼節(jié)點(diǎn)需要喚醒碎紊，
//釋放同步狀態(tài)就是相當(dāng)于unpark頭結(jié)點(diǎn)的后繼節(jié)點(diǎn)。
private void doReleaseShared() {
    //即使有其他正在進(jìn)行的同步狀態(tài)的獲取/釋放樊诺，也要確保傳播同步狀態(tài)仗考。
    //如果頭結(jié)點(diǎn)的后繼者需要signal，那么unpark后繼者词爬。
    //如果后繼節(jié)點(diǎn)不需要signal秃嗜，當(dāng)頭結(jié)點(diǎn)釋放同步狀態(tài)后，
    //將自己的狀態(tài)設(shè)置為propagate顿膨，以確保同步狀態(tài)被傳播锅锨。
    //此外，必須將這些操作放在循環(huán)中恋沃，
    //以防我們做這些操作的時(shí)候必搞，新的節(jié)點(diǎn)被加入進(jìn)來(lái)。
    //而且囊咏，不像unparkSuccessor其他使用那樣恕洲，在這里
    //需要知道CAS重置狀態(tài)失敗的情況，所以需要重新檢查梅割。
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            //如果頭結(jié)點(diǎn)狀態(tài)為signal霜第，那么將自己狀態(tài)修改為0，
            //修改成功后户辞，喚醒后繼節(jié)點(diǎn)泌类。
            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
        }
        //確保頭結(jié)點(diǎn)在本次釋放操作中沒(méi)有被修改。
        if (h == head)                   // loop if head changed
            break;
    }
}

嘻嘻底燎，如果文章有錯(cuò)誤的地方刃榨，麻煩小哥哥小姐姐幫忙指出改正，一起學(xué)習(xí)书蚪，一起交流喇澡。