摘要：當前節點擁有的線程。方法返回值表示在線程等待過程中，是否有另一個線程調用該線程的方法，發起中斷。如果前一個節點狀態是，那么直接返回，阻塞當前線程如果前一個節點狀態是大于就是，表示前一個

AQS是JUC鎖框架中最重要的類，通過它來實現獨占鎖和共享鎖的。本章是對AbstractQueuedSynchronizer源碼的完全解析，分為四個部分介紹：

CLH隊列即同步隊列：儲存著所有等待鎖的線程
獨占鎖
共享鎖
Condition條件

注: 還有一個AbstractQueuedLongSynchronizer類，它與AQS功能和實現幾乎一樣，唯一不同的是AQLS中代表鎖被獲取次數的成員變量state類型是long長整類型，而AQS中該成員變量是int類型。

因為獲取鎖是有條件的，沒有獲取鎖的線程就要阻塞等待，那么就要存儲這些等待的線程。

在AQS中我們使用CLH隊列儲存這些等待的線程，但它并不是直接儲存線程，而是儲存擁有線程的node節點。所以先介紹重要內部類Node。

   static final class Node {
        // 共享模式的標記
        static final Node SHARED = new Node();
        // 獨占模式的標記
        static final Node EXCLUSIVE = null;

        // waitStatus變量的值，標志著線程被取消
        static final int CANCELLED =  1;
        // waitStatus變量的值，標志著后繼線程(即隊列中此節點之后的節點)需要被阻塞.(用于獨占鎖)
        static final int SIGNAL    = -1;
        // waitStatus變量的值，標志著線程在Condition條件上等待阻塞.(用于Condition的await等待)
        static final int CONDITION = -2;
        // waitStatus變量的值，標志著下一個acquireShared方法線程應該被允許。(用于共享鎖)
        static final int PROPAGATE = -3;

        // 標記著當前節點的狀態，默認狀態是0, 小于0的狀態都是有特殊作用，大于0的狀態表示已取消
        volatile int waitStatus;

        // prev和next實現一個雙向鏈表
        volatile Node prev;
        volatile Node next;

        // 該節點擁有的線程
        volatile Thread thread;

        // 可能有兩種作用：1. 表示下一個在Condition條件上等待的節點
        // 2. 表示是共享模式或者獨占模式，注意第一種情況節點一定是共享模式
        Node nextWaiter;

        // 是不是共享模式
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        // 返回前一個節點prev，如果為null，則拋出NullPointerException異常
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        // 用于創建鏈表頭head，或者共享模式SHARED
        Node() {
        }

        // 使用在addWaiter方法中
        Node(Thread thread, Node mode) {
            this.nextWaiter = mode;
            this.thread = thread;
        }

        // 使用在Condition條件中
        Node(Thread thread, int waitStatus) {
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

重要的成員屬性：

waitStatus: 表示當前節點的狀態，默認狀態是0。總共有五個值CANCELLED、SIGNAL、CONDITION、PROPAGATE以及0。
prev和next：記錄著當前節點前一個節點和后一個節點的引用。
thread：當前節點擁有的線程。當擁有鎖的線程釋放鎖的時候，可能會調用LockSupport.unpark(thread)，喚醒這個被阻塞的線程。
nextWaiter：如果是SHARED，表示當前節點是共享模式，如果是null，當前節點是獨占模式，如果是其他值，當前節點也是獨占模式，不過這個值也是Condition隊列的下一個節點。

注意：通過Node我們可以實現兩個隊列，一是通過prev和next實現CLH隊列(線程同步隊列,雙向隊列)，二是nextWaiter實現Condition條件上的等待線程隊列(單向隊列)，后一個我們在Condition中介紹。

    // CLH隊列頭
    private transient volatile Node head;

    // CLH隊列尾
    private transient volatile Node tail;

    /**
     * 通過CAS函數設置head值，僅僅在enq方法中調用
     */
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

這個方法只在enq方法中調用，通過CAS函數設置head值，保證多線程安全

   // 重新設置隊列頭head，它只在acquire系列的方法中調用
    private void setHead(Node node) {
        head = node;
        // 線程也沒有意義了，因為該線程已經獲取到鎖了
        node.thread = null;
        // 前一個節點已經沒有意義了
        node.prev = null;
    }

這個方法只在acquire系列的方法中調用，重新設置head，表示移除一些等待線程節點。

    /**
     * 通過CAS函數設置tail值，僅僅在enq方法中調用
     */
    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

這個方法只在enq方法中調用，通過CAS函數設置tail值，保證多線程安全

   // 向隊列尾插入新節點，如果隊列沒有初始化，就先初始化。返回原先的隊列尾節點
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            // t為null，表示隊列為空，先初始化隊列
            if (t == null) {
                // 采用CAS函數即原子操作方式，設置隊列頭head值。
                // 如果成功，再將head值賦值給鏈表尾tail。如果失敗，表示head值已經被其他線程，那么就進入循環下一次
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                // 新添加的node節點的前一個節點prev指向原來的隊列尾tail
                node.prev = t;
                // 采用CAS函數即原子操作方式，設置新隊列尾tail值。
                if (compareAndSetTail(t, node)) {
                    // 設置老的隊列尾tail的下一個節點next指向新添加的節點node
                    t.next = node;
                    return t;
                }
            }
        }
    }

這個方法向CLH隊列尾插入一個新節點，如果隊列為空，就先創建隊列再插入新節點，返回老的隊列尾節點。

   // 通過給定的模式mode(獨占或者共享)為當前線程創建新節點，并插入隊列中
    private Node addWaiter(Node mode) {
        // 為當前線程創建新的節點
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        // 如果隊列已經創建，就將新節點插入隊列尾。
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 如果隊列沒有創建，通過enq方法創建隊列，并插入新的節點。
        enq(node);
        return node;
    }

為當前線程創建一個新節點，再插入到CLH隊列尾，返回新創建的節點。

我們先想一想獨占鎖的功能是什么?

獨占鎖至少有兩個功能：

獲取鎖的功能。 當多個線程一起獲取鎖的時候，只有一個線程能獲取到鎖，其他線程必須在當前位置阻塞等待。
釋放鎖的功能。獲取鎖的線程釋放鎖資源，而且還必須能喚醒正在等待鎖資源的一個線程。

帶著這些疑惑，我們來看AQS中是怎么實現的。

   /**
     * 獲取獨占鎖。如果沒有獲取到，線程就會阻塞等待，直到獲取鎖。不會響應中斷異常
     * @param arg
     */
    public final void acquire(int arg) {
        // 1. 先調用tryAcquire方法，嘗試獲取獨占鎖，返回true，表示獲取到鎖，不需要執行acquireQueued方法。
        // 2. 調用acquireQueued方法，先調用addWaiter方法為當前線程創建一個節點node，并插入隊列中，
        // 然后調用acquireQueued方法去獲取鎖，如果不成功，就會讓當前線程阻塞，當鎖釋放時才會被喚醒。
        // acquireQueued方法返回值表示在線程等待過程中，是否有另一個線程調用該線程的interrupt方法，發起中斷。
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

將這個方法一下格式，大家就很好理解了

   public final void acquire(int arg) {
        // 1.先調用tryAcquire方法，嘗試獲取獨占鎖，返回true則直接返回
        if (tryAcquire(arg)) return;
        // 2. 調用addWaiter方法為當前線程創建一個節點node，并插入隊列中
        Node node = addWaiter(Node.EXCLUSIVE);
        // 調用acquireQueued方法去獲取鎖，
        // acquireQueued方法返回值表示在線程等待過程中，是否有另一個線程調用該線程的interrupt方法，發起中斷。
        boolean interrupted = acquireQueued(node, arg);
        // 如果interrupted為true，則當前線程要發起中斷請求
        if (interrupted) {
            selfInterrupt();
        }
    }

    // 嘗試去獲取獨占鎖，立即返回。如果返回true表示獲取鎖成功。
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

如果子類想實現獨占鎖，則必須重寫這個方法，否則拋出異常。這個方法的作用是當前線程嘗試獲取鎖，如果獲取到鎖，就會返回true，并更改鎖資源。沒有獲取到鎖返回false。

注：這個方法是立即返回的，不會阻塞當前線程

下面是ReentrantLock中FairSync的tryAcquire方法實現

       // 嘗試獲取鎖，與非公平鎖最大的不同就是調用hasQueuedPredecessors()方法
        // hasQueuedPredecessors方法返回true，表示等待線程隊列中有一個線程在當前線程之前，
        // 根據公平鎖的規則，當前線程不能獲取鎖。
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 獲取鎖的記錄狀態
            int c = getState();
            // 如果c==0表示當前鎖是空閑的
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 判斷當前線程是不是獨占鎖的線程
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                // 更改鎖的記錄狀態
                setState(nextc);
                return true;
            }
            return false;
        }

addWaiter方法已經在上面講解了。acquireQueued方法作用就是獲取鎖，如果沒有獲取到，就讓當前線程阻塞等待。

     /**
     * 想要獲取鎖的 acquire系列方法，都會這個方法來獲取鎖
     * 循環通過tryAcquire方法不斷去獲取鎖，如果沒有獲取成功，
     * 就有可能調用parkAndCheckInterrupt方法，讓當前線程阻塞
     * @param node 想要獲取鎖的節點
     * @param arg
     * @return 返回true，表示在線程等待的過程中，線程被中斷了
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            // 表示線程在等待過程中，是否被中斷了
            boolean interrupted = false;
            // 通過死循環，直到node節點的線程獲取到鎖，才返回
            for (;;) {
                // 獲取node的前一個節點
                final Node p = node.predecessor();
                // 如果前一個節點是隊列頭head，并且嘗試獲取鎖成功
                // 那么當前線程就不需要阻塞等待，繼續執行
                if (p == head && tryAcquire(arg)) {
                    // 將節點node設置為新的隊列頭
                    setHead(node);
                    // help GC
                    p.next = null;
                    // 不需要調用cancelAcquire方法
                    failed = false;
                    return interrupted;
                }
                // 當p節點的狀態是Node.SIGNAL時，就會調用parkAndCheckInterrupt方法，阻塞node線程
                // node線程被阻塞，有兩種方式喚醒，
                // 1.是在unparkSuccessor(Node node)方法，會喚醒被阻塞的node線程，返回false
                // 2.node線程被調用了interrupt方法，線程被喚醒，返回true
                // 在這里只是簡單地將interrupted = true，沒有跳出for的死循環，繼續嘗試獲取鎖
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            // failed為true，表示發生異常，非正常退出
            // 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了。
            if (failed)
                cancelAcquire(node);
        }
    }

主要流程：

通過for (;;)死循環，直到node節點的線程獲取到鎖，才跳出循環。
獲取node節點的前一個節點p。
當前一個節點p時CLH隊列頭節點時，調用tryAcquire方法嘗試去獲取鎖，如果獲取成功，就將節點node設置成CLH隊列頭節點(相當于移除節點node和之前的節點)然后return返回。
注意:只有當node節點的前一個節點是隊列頭節點時，才會嘗試獲取鎖，所以獲取鎖是有順序的，按照添加到CLH隊列時的順序。
調用shouldParkAfterFailedAcquire方法，來決定是否要阻塞當前線程。
調用parkAndCheckInterrupt方法，阻塞當前線程。
如果當前線程發生異常，非正常退出，那么會在finally模塊中調用cancelAcquire(node)方法，取消當前節點狀態。

注意：這里當嘗試獲取鎖失敗時，并沒有立即阻塞當前線程，但是因為在for (;;)死循環里，會繼續循環，方法不會返回。

這個方法的返回值決定是否要阻塞當前線程

    /**
     * 根據前一個節點pred的狀態，來判斷當前線程是否應該被阻塞
     * @param pred : node節點的前一個節點
     * @param node
     * @return 返回true 表示當前線程應該被阻塞，之后應該會調用parkAndCheckInterrupt方法來阻塞當前線程
     */
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            // 如果前一個pred的狀態是Node.SIGNAL，那么直接返回true，當前線程應該被阻塞
            return true;
        if (ws > 0) {
            // 如果前一個節點狀態是Node.CANCELLED(大于0就是CANCELLED)，
            // 表示前一個節點所在線程已經被喚醒了，要從CLH隊列中移除CANCELLED的節點。
            // 所以從pred節點一直向前查找直到找到不是CANCELLED狀態的節點，并把它賦值給node.prev，
            // 表示node節點的前一個節點已經改變。
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            // 此時前一個節點pred的狀態只能是0或者PROPAGATE，不可能是CONDITION狀態
            // CONDITION(這個是特殊狀態，只在condition列表中節點中存在，CLH隊列中不存在這個狀態的節點)
            // 將前一個節點pred的狀態設置成Node.SIGNAL，這樣在下一次循環時，就是直接阻塞當前線程
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

我們發現是根據前一個節點的狀態，來決定是否阻塞當前線程。而前一個節點狀態是在哪里改變的呢？驚奇地發現也是在這個方法中改變的。

如果前一個節點狀態是Node.SIGNAL，那么直接返回true，阻塞當前線程
如果前一個節點狀態是Node.CANCELLED(大于0就是CANCELLED)，表示前一個節點所在線程已經被喚醒了，要從CLH隊列中移除CANCELLED的節點。所以從pred節點一直向前查找直到找到不是CANCELLED狀態的節點。

并把它賦值給node.prev，表示node節點的前一個節點已經改變。在acquireQueued方法中進行下一次循環。
不是前面兩種狀態，那么就將前一個節點狀態設置成Node.SIGNAL，表示需要阻塞當前線程，這樣再下一次循環時，就會直接阻塞當前線程。

阻塞當前線程，線程被喚醒后返回當前線程中斷狀態

    /**
     * 阻塞當前線程，線程被喚醒后返回當前線程中斷狀態
     */
    private final boolean parkAndCheckInterrupt() {
        // 通過LockSupport.park方法，阻塞當前線程
        LockSupport.park(this);
        // 當前線程被喚醒后，返回當前線程中斷狀態
        return Thread.interrupted();
    }

通過LockSupport.park(this)阻塞當前線程。

將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了。

    // 將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了。
    private void cancelAcquire(Node node) {
        // 如果node為null，就直接返回
        if (node == null)
            return;

        //
        node.thread = null;

        // 跳過那些已取消的節點，在隊列中找到在node節點前面的第一次狀態不是已取消的節點
        Node pred = node.prev;
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;

        // 記錄pred原來的下一個節點，用于CAS函數更新時使用
        Node predNext = pred.next;

        // Can use unconditional write instead of CAS here.
        // After this atomic step, other Nodes can skip past us.
        // Before, we are free of interference from other threads.
        // 將node節點狀態設置為已取消Node.CANCELLED;
        node.waitStatus = Node.CANCELLED;

        // 如果node節點是隊列尾節點，那么就將pred節點設置為新的隊列尾節點
        if (node == tail && compareAndSetTail(node, pred)) {
            // 并且設置pred節點的下一個節點next為null
            compareAndSetNext(pred, predNext, null);
        } else {
            // If successor needs signal, try to set pred"s next-link
            // so it will get one. Otherwise wake it up to propagate.
            int ws;
            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 {
                unparkSuccessor(node);
            }

            node.next = node; // help GC
        }
    }

tryAcquire方法嘗試獲取獨占鎖，由子類實現
acquireQueued方法，方法內采用for死循環，先調用tryAcquire方法，嘗試獲取鎖，如果成功，則跳出循環方法返回。 如果失敗，就可能阻塞當前線程。當別的線程鎖釋放的時候，可能會喚醒這個線程，然后再次進行循環判斷，調用tryAcquire方法，嘗試獲取鎖。
如果發生異常，該線程被喚醒，所以要取消節點node的狀態，因為節點node所在線程不是在阻塞狀態了。

注：還有其他獲取獨占鎖的方法，例如doAcquireInterruptibly、doAcquireNanos都在文章最后的源碼解析中，這里就不做解析了，具體原理都差不多。

    // 在獨占鎖模式下，釋放鎖的操作
    public final boolean release(int arg) {
        // 調用tryRelease方法，嘗試去釋放鎖，由子類具體實現
        if (tryRelease(arg)) {
            Node h = head;
            // 如果隊列頭節點的狀態不是0，那么隊列中就可能存在需要喚醒的等待節點。
            // 還記得我們在acquireQueued(final Node node, int arg)獲取鎖的方法中，如果節點node沒有獲取到鎖，
            // 那么我們會將節點node的前一個節點狀態設置為Node.SIGNAL，然后調用parkAndCheckInterrupt方法
            // 將節點node所在線程阻塞。
            // 在這里就是通過unparkSuccessor方法，進而調用LockSupport.unpark(s.thread)方法，喚醒被阻塞的線程
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

調用tryRelease方法釋放鎖資源，返回true表示鎖資源完全釋放了，返回false表示還持有鎖資源。
如果鎖資源完全被釋放了，就要喚醒等待鎖資源的線程。調用unparkSuccessor方法喚醒一個等待線程

注：CLH隊列頭節點h為null，表示隊列為空，沒有節點。節點h的狀態是0，表示沒有CLH隊列中沒有被阻塞的線程。

     // 嘗試去釋放當前線程持有的獨占鎖，立即返回。如果返回true表示釋放鎖成功
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

如果子類想實現獨占鎖，則必須重寫這個方法，否則拋出異常。作用是釋放當前線程持有的鎖，返回true表示已經完全釋放鎖資源，返回false，表示還持有鎖資源。

注：對于獨占鎖來說，同一時間只能有一個線程持有這個鎖，但是這個線程可以重復地獲取鎖，因為被鎖住的模塊，再次進入另一個被這個鎖鎖住的模塊，是允許的。這個就做可重入性，所以對于可重入的鎖釋放操作，也需要多次。

下面是ReentrantLock中Sync的tryRelease方法實現

   protected final boolean tryRelease(int releases) {
            // c表示新的鎖的記錄狀態
            int c = getState() - releases;
            // 如果當前線程不是獨占鎖的線程，就拋出IllegalMonitorStateException異常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            // 標志是否可以釋放鎖
            boolean free = false;
            // 當新的鎖的記錄狀態為0時，表示可以釋放鎖
            if (c == 0) {
                free = true;
                // 設置獨占鎖的線程為null
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

   // 喚醒node節點的下一個非取消狀態的節點所在線程(即waitStatus<=0)
    private void unparkSuccessor(Node node) {
        // 獲取node節點的狀態
        int ws = node.waitStatus;
        // 如果小于0，就將狀態重新設置為0，表示這個node節點已經完成了
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        // 下一個節點
        Node s = node.next;
        // 如果下一個節點為null，或者狀態是已取消，那么就要尋找下一個非取消狀態的節點
        if (s == null || s.waitStatus > 0) {
            // 先將s設置為null，s不是非取消狀態的節點
            s = null;
            // 從隊列尾向前遍歷，直到遍歷到node節點
            for (Node t = tail; t != null && t != node; t = t.prev)
                // 因為是從后向前遍歷，所以不斷覆蓋找到的值，這樣才能得到node節點后下一個非取消狀態的節點
                if (t.waitStatus <= 0)
                    s = t;
        }
        // 如果s不為null，表示存在非取消狀態的節點。那么調用LockSupport.unpark方法，喚醒這個節點的線程
        if (s != null)
            LockSupport.unpark(s.thread);
    }

這個方法的作用是喚醒node節點的下一個非取消狀態的節點所在線程。

將node節點的狀態設置為0
尋找到下一個非取消狀態的節點s
如果節點s不為null，則調用LockSupport.unpark(s.thread)方法喚醒s所在線程。

注：喚醒線程也是有順序的，就是添加到CLH隊列線程的順序。

調用tryRelease方法去釋放當前持有的鎖資源。
如果完全釋放了鎖資源，那么就調用unparkSuccessor方法，去喚醒一個等待鎖的線程。

共享鎖與獨占鎖相比，共享鎖可能被多個線程共同持有

    // 獲取共享鎖
    public final void acquireShared(int arg) {
        // 嘗試去獲取共享鎖，如果返回值小于0表示獲取共享鎖失敗
        if (tryAcquireShared(arg) < 0)
            // 調用doAcquireShared方法去獲取共享鎖
            doAcquireShared(arg);
    }

調用tryAcquireShared方法嘗試獲取共享鎖，如果返回值小于0表示獲取共享鎖失敗.則繼續調用doAcquireShared方法獲取共享鎖。

     // 嘗試去獲取共享鎖，立即返回。返回值大于等于0，表示獲取共享鎖成功
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

如果子類想實現共享鎖，則必須重寫這個方法，否則拋出異常。作用是嘗試獲取共享鎖，返回值大于等于0，表示獲取共享鎖成功。

下面是ReentrantReadWriteLock中Sync的tryReleaseShared方法實現,這個我們會在ReentrantReadWriteLock章節中重點介紹的。

      protected final boolean tryReleaseShared(int unused) {
            Thread current = Thread.currentThread();
            // 當前線程是第一個獲取讀鎖(共享鎖)的線程
            if (firstReader == current) {
                // 將firstReaderHoldCount減一，如果就是1，那么表示該線程需要釋放讀鎖(共享鎖)，
                // 將firstReader設置為null
                if (firstReaderHoldCount == 1)
                    firstReader = null;
                else
                    firstReaderHoldCount--;
            } else {
                HoldCounter rh = cachedHoldCounter;
                // 獲取當前線程的HoldCounter變量
                if (rh == null || rh.tid != getThreadId(current))
                    rh = readHolds.get();
                // 將rh變量的count減一，
                int count = rh.count;
                if (count <= 1) {
                    readHolds.remove();
                    // count <= 0表示當前線程就沒有獲取到讀鎖(共享鎖)，這里釋放就拋出異常。
                    if (count <= 0)
                        throw unmatchedUnlockException();
                }
                --rh.count;
            }
            for (;;) {
                int c = getState();
                // 因為讀鎖是利用高16位儲存的，低16位的數據是要屏蔽的，
                // 所以這里減去SHARED_UNIT(65536)，相當于減一
                // 表示一個讀鎖已經釋放
                int nextc = c - SHARED_UNIT;
                // 利用CAS函數重新設置state值
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }

    /**
     * 獲取共享鎖，獲取失敗，則會阻塞當前線程，直到獲取共享鎖返回
     * @param arg the acquire argument
     */
    private void doAcquireShared(int arg) {
        // 為當前線程創建共享鎖節點node
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                // 如果節點node前一個節點是同步隊列頭節點。就會調用tryAcquireShared方法嘗試獲取共享鎖
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    // 如果返回值大于0，表示獲取共享鎖成功
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                // 如果節點p的狀態是Node.SIGNAL，就是調用parkAndCheckInterrupt方法阻塞當前線程
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
             // failed為true，表示發生異常，
            // 則將node節點的狀態設置成CANCELLED，表示node節點所在線程已取消，不需要喚醒了
            if (failed)
                cancelAcquire(node);
        }
    }

這個方法與獨占鎖的acquireQueued方法相比較，不同的有三點：

doAcquireShared方法，調用addWaiter(Node.SHARED)方法，為當前線程創建一個共享模式的節點node。而acquireQueued方法是由外部傳遞來的。
doAcquireShared方法沒有返回值，acquireQueued方法會返回布爾類型的值，是當前線程中斷標志位值
最大的區別是重新設置CLH隊列頭的方法不一樣。doAcquireShared方法調用setHeadAndPropagate方法，而acquireQueued方法調用setHead方法。

     // 重新設置CLH隊列頭，如果CLH隊列頭的下一個節點為null或者共享模式，
    // 那么就要喚醒共享鎖上等待的線程
    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head;
        // 設置新的同步隊列頭head
        setHead(node);
        // 如果propagate大于0，
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
            (h = head) == null || h.waitStatus < 0) {
            // 獲取新的CLH隊列頭的下一個節點s
            Node s = node.next;
            // 如果節點s是空或者共享模式節點，那么就要喚醒共享鎖上等待的線程
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

     // 釋放共享鎖
    public final boolean releaseShared(int arg) {
        // 嘗試釋放共享鎖
        if (tryReleaseShared(arg)) {
            // 喚醒等待共享鎖的線程
            doReleaseShared();
            return true;
        }
        return false;
    }

     // 嘗試去釋放共享鎖
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }

如果子類想實現共享鎖，則必須重寫這個方法，否則拋出異常。作用是釋放當前線程持有的鎖，返回true表示已經完全釋放鎖資源，返回false，表示還持有鎖資源。

     // 會喚醒等待共享鎖的線程
    private void doReleaseShared() {
        for (;;) {
            // 將同步隊列頭賦值給節點h
            Node h = head;
            // 如果節點h不為null，且不等于同步隊列尾
            if (h != null && h != tail) {
                // 得到節點h的狀態
                int ws = h.waitStatus;
                // 如果狀態是Node.SIGNAL，就要喚醒節點h后繼節點的線程
                if (ws == Node.SIGNAL) {
                    // 將節點h的狀態設置成0，如果設置失敗，就繼續循環，再試一次。
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                        continue;            // loop to recheck cases
                    // 喚醒節點h后繼節點的線程
                    unparkSuccessor(h);
                }
                // 如果節點h的狀態是0，就設置ws的狀態是PROPAGATE。
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            // 如果同步隊列頭head節點發生改變，繼續循環，
            // 如果沒有改變，就跳出循環
            if (h == head)
                break;
        }
    }

Condition是為了實現線程之間相互等待的問題。注意Condition對象只能在獨占鎖中才能使用。

考慮一下情況，有兩個線程，生產者線程，消費者線程。當消費者線程消費東西時，發現沒有東西，這時它就要等待，讓生產者線程生產東西后，在通知它消費。
因為操作的是同一個資源，所以要加鎖，防止多線程沖突。而鎖在同一時間只能有一個線程持有，所以消費者在讓線程等待前，必須釋放鎖，且喚醒另一個等待鎖的線程。
那么在AQS中Condition條件又是如何實現的呢？

首先內部存在一個Condition隊列，存儲著所有在此Condition條件等待的線程。
await系列方法：讓當前持有鎖的線程釋放鎖，并喚醒一個在CLH隊列上等待鎖的線程，再為當前線程創建一個node節點，插入到Condition隊列(注意不是插入到CLH隊列中)
signal系列方法：其實這里沒有喚醒任何線程，而是將Condition隊列上的等待節點插入到CLH隊列中，所以當持有鎖的線程執行完畢釋放鎖時，就會喚醒CLH隊列中的一個線程，這個時候才會喚醒線程。

     /**
         * 讓當前持有鎖的線程阻塞等待，并釋放鎖。如果有中斷請求，則拋出InterruptedException異常
         * @throws InterruptedException
         */
        public final void await() throws InterruptedException {
            // 如果當前線程中斷標志位是true，就拋出InterruptedException異常
            if (Thread.interrupted())
                throw new InterruptedException();
            // 為當前線程創建新的Node節點，并且將這個節點插入到Condition隊列中了
            Node node = addConditionWaiter();
            // 釋放當前線程占有的鎖，并喚醒CLH隊列一個等待線程
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            // 如果節點node不在同步隊列中(注意不是Condition隊列)
            while (!isOnSyncQueue(node)) {
                // 阻塞當前線程,那么怎么喚醒這個線程呢？
                // 首先我們必須調用signal或者signalAll將這個節點node加入到同步隊列。
                // 只有這樣unparkSuccessor(Node node)方法，才有可能喚醒被阻塞的線程
                LockSupport.park(this);
                // 如果當前線程產生中斷請求，就跳出循環
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            // 如果節點node已經在同步隊列中了，獲取同步鎖，只有得到鎖才能繼續執行，否則線程繼續阻塞等待
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            // 清除Condition隊列中狀態不是Node.CONDITION的節點
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            // 是否要拋出異常，或者發出中斷請求
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

方法流程：

addConditionWaiter方法：為當前線程創建新的Node節點，并且將這個節點插入到Condition隊列中了
fullyRelease方法：釋放當前線程占有的鎖，并喚醒CLH隊列一個等待線程
isOnSyncQueue 方法：如果返回false，表示節點node不在CLH隊列中，即沒有調用過 signal系列方法，所以調用LockSupport.park(this)方法阻塞當前線程。
如果跳出while循環，表示節點node已經在CLH隊列中，那么調用acquireQueued方法去獲取鎖。
清除Condition隊列中狀態不是Node.CONDITION的節點

為當前線程創建新的Node節點，并且將這個節點插入到Condition隊列中了

    private Node addConditionWaiter() {
            Node t = lastWaiter;
            // 如果Condition隊列尾節點的狀態不是Node.CONDITION
            if (t != null && t.waitStatus != Node.CONDITION) {
                // 清除Condition隊列中，狀態不是Node.CONDITION的節點，
                // 并且可能會重新設置firstWaiter和lastWaiter
                unlinkCancelledWaiters();
                // 重新將Condition隊列尾賦值給t
                t = lastWaiter;
            }
            // 為當前線程創建一個狀態為Node.CONDITION的節點
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            // 如果t為null，表示Condition隊列為空，將node節點賦值給鏈表頭
            if (t == null)
                firstWaiter = node;
            else
                // 將新節點node插入到Condition隊列尾
                t.nextWaiter = node;
            // 將新節點node設置為新的Condition隊列尾
            lastWaiter = node;
            return node;
        }

釋放當前線程占有的鎖，并喚醒CLH隊列一個等待線程

    /**
     * 釋放當前線程占有的鎖，并喚醒CLH隊列一個等待線程
     * 如果失敗就拋出異常，設置node節點的狀態是Node.CANCELLED
     * @return
     */
    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();
            // 釋放當前線程占有的鎖
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }

節點node是不是在CLH隊列中

    // 節點node是不是在CLH隊列中
    final boolean isOnSyncQueue(Node node) {
        // 如果node的狀態是Node.CONDITION，或者node沒有前一個節點prev，
        // 那么返回false，節點node不在同步隊列中
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        // 如果node有下一個節點next，那么它一定在同步隊列中
        if (node.next != null) // If has successor, it must be on queue
            return true;
        // 從同步隊列中查找節點node
        return findNodeFromTail(node);
    }

    // 在同步隊列中從后向前查找節點node，如果找到返回true，否則返回false
    private boolean findNodeFromTail(Node node) {
        Node t = tail;
        for (;;) {
            if (t == node)
                return true;
            if (t == null)
                return false;
            t = t.prev;
        }
    }

獲取獨占鎖，這個在獨占鎖章節已經說過

清除Condition隊列中狀態不是Node.CONDITION的節點

    private void unlinkCancelledWaiters() {
            // condition隊列頭賦值給t
            Node t = firstWaiter;
            // 這個trail節點，只是起輔助作用
            Node trail = null;
            while (t != null) {
                //得到下一個節點next。當節點是condition時候，nextWaiter表示condition隊列的下一個節點
                Node next = t.nextWaiter;
                // 如果節點t的狀態不是CONDITION，那么該節點就要從condition隊列中移除
                if (t.waitStatus != Node.CONDITION) {
                    // 將節點t的nextWaiter設置為null
                    t.nextWaiter = null;
                    // 如果trail為null，表示原先的condition隊列頭節點實效，需要設置新的condition隊列頭
                    if (trail == null)
                        firstWaiter = next;
                    else
                        // 將節點t從condition隊列中移除，因為改變了引用的指向，從condition隊列中已經找不到節點t了
                        trail.nextWaiter = next;
                    // 如果next為null，表示原先的condition隊列尾節點也實效，重新設置隊列尾節點
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    // 遍歷到的有效節點
                    trail = t;
                // 將next賦值給t，遍歷完整個condition隊列
                t = next;
            }
        }

    /**
         * 如果interruptMode是THROW_IE，就拋出InterruptedException異常
         * 如果interruptMode是REINTERRUPT，則當前線程再發出中斷請求
         * 否則就什么都不做
         */
        private void reportInterruptAfterWait(int interruptMode)
            throws InterruptedException {
            if (interruptMode == THROW_IE)
                throw new InterruptedException();
            else if (interruptMode == REINTERRUPT)
                selfInterrupt();
        }

       // 如果condition隊列不為空，將condition隊列頭節點插入到同步隊列中
        public final void signal() {
            // 如果當前線程不是獨占鎖線程，就拋出IllegalMonitorStateException異常
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();

            // 將Condition隊列頭賦值給節點first
            Node first = firstWaiter;
            if (first != null)
                //  將Condition隊列中的first節點插入到CLH隊列中
                doSignal(first);
        }

如果condition隊列不為空，就調用doSignal方法將condition隊列頭節點插入到CLH隊列中。

        // 將Condition隊列中的first節點插入到CLH隊列中
        private void doSignal(Node first) {
            do {
                // 原先的Condition隊列頭節點取消，所以重新賦值Condition隊列頭節點
                // 如果新的Condition隊列頭節點為null，表示Condition隊列為空了
                // ，所以也要設置Condition隊列尾lastWaiter為null
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                // 取消first節點nextWaiter引用
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

為什么使用while循環，因為只有是Node.CONDITION狀態的節點才能插入CLH隊列，如果不是這個狀態，那么循環Condition隊列下一個節點。

      // 返回true表示節點node插入到同步隊列中，返回false表示節點node沒有插入到同步隊列中
    final boolean transferForSignal(Node node) {
        // 如果節點node的狀態不是Node.CONDITION，或者更新狀態失敗，
        // 說明該node節點已經插入到同步隊列中，所以直接返回false
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;

        // 將節點node插入到同步隊列中，p是原先同步隊列尾節點，也是node節點的前一個節點
        Node p = enq(node);
        int ws = p.waitStatus;
        // 如果前一個節點是已取消狀態，或者不能將它設置成Node.SIGNAL狀態。
        // 就說明節點p之后也不會發起喚醒下一個node節點線程的操作，
        // 所以這里直接調用 LockSupport.unpark(node.thread)方法，喚醒節點node所在線程
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

狀態不是 Node.CONDITION的節點，是不能從Condition隊列中插入到CLH隊列中。直接返回false
調用enq方法，將節點node插入到同步隊列中，p是原先同步隊列尾節點，也是node節點的前一個節點
如果前一個節點是已取消狀態，或者不能將它設置成Node.SIGNAL狀態。那么就要LockSupport.unpark(node.thread)方法喚醒node節點所在線程。

     // 將condition隊列中所有的節點都插入到同步隊列中
        public final void signalAll() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignalAll(first);
        }

    /**
         * 將condition隊列中所有的節點都插入到同步隊列中
         * @param first condition隊列頭節點
         */
        private void doSignalAll(Node first) {
            // 表示將condition隊列設置為空
            lastWaiter = firstWaiter = null;
            do {
                // 得到condition隊列的下一個節點
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                // 將節點first插入到同步隊列中
                transferForSignal(first);
                first = next;
                // 循環遍歷condition隊列中所有的節點
            } while (first != null);
        }

循環遍歷整個condition隊列，調用transferForSignal方法，將節點插入到CLH隊列中。

Condition只能使用在獨占鎖中。它內部有一個Condition隊列記錄所有在Condition條件等待的線程(即就是調用await系列方法后等待的線程).
await系列方法：會讓當前線程釋放持有的鎖，并喚醒在CLH隊列上的一個等待鎖的線程，再將當前線程插入到Condition隊列中(注意不是CLH隊列)
signal系列方法：并不是喚醒線程，而是將Condition隊列中的節點插入到CLH隊列中。

使用AQS類來實現獨占鎖和共享鎖：

內部有一個CLH隊列，用來記錄所有等待鎖的線程
通過 acquire系列方法用來獲取獨占鎖，獲取失敗，則阻塞當前線程
通過release方法用來釋放獨占鎖，釋放成功，則會喚醒一個等待獨占鎖的線程。
通過acquireShared系列方法用來獲取共享鎖。
通過releaseShared方法用來釋放共享鎖。
通過Condition來實現線程之間相互等待的。

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// 實現一個可重入的獨占鎖， 必須復寫tryAcquire和tryRelease方法
class Sync extends AbstractQueuedSynchronizer {
    // 嘗試獲取獨占鎖， 利用鎖的獲取次數state屬性
    @Override
    protected boolean tryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        // 獲取鎖的記錄狀態state
        int c = getState();
        // 如果c==0表示當前鎖是空閑的
        if (c == 0) {
            // 通過CAS原子操作方式設置鎖的狀態，如果為true，表示當前線程獲取的鎖，
            // 為false，鎖的狀態被其他線程更改，當前線程獲取的鎖失敗
            if (compareAndSetState(0, acquires)) {
                // 設置當前線程為獨占鎖的線程
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 判斷當前線程是不是獨占鎖的線程，因為是可重入鎖
        else if (current == getExclusiveOwnerThread()) {
            int nextc = c + acquires;
            if (nextc < 0)
                throw new Error("Maximum lock count exceeded");
            // 更改鎖的記錄狀態
            setState(nextc);
            return true;
        }
        return false;
    }

    // 釋放持有的獨占鎖， 因為是可重入鎖，所以只有當c等于0的時候，表示當前持有鎖的完全釋放了鎖。
    @Override
    protected boolean tryRelease(int releases) {
        // c表示新的鎖的記錄狀態
        int c = getState() - releases;
        // 如果當前線程不是獨占鎖的線程，就拋出IllegalMonitorStateException異常
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        // 標志是否可以釋放鎖
        boolean free = false;
        // 當新的鎖的記錄狀態為0時，表示可以釋放鎖
        if (c == 0) {
            free = true;
            // 設置獨占鎖的線程為null
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
}

public class AQSTest {

    public static void newThread(Sync sync, String name, int time) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("線程"+Thread.currentThread().getName()+" 開始運行，準備獲取鎖");
                // 通過acquire方法，獲取鎖，如果沒有獲取到，就等待
                sync.acquire(1);
                try {
                    System.out.println("====線程"+Thread.currentThread().getName()+" 在run方法中獲取了鎖");
                    lockAgain();
                    try {
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("----線程"+Thread.currentThread().getName()+" 在run方法中釋放了鎖");
                    sync.release(1);
                }
            }

            private void lockAgain() {
                sync.acquire(1);
                try {
                    System.out.println("====線程"+Thread.currentThread().getName()+"  在lockAgain方法中再次獲取了鎖");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("----線程"+Thread.currentThread().getName()+" 在lockAgain方法中釋放了鎖");
                    sync.release(1);
                }
            }
        },name).start();
    }

    public static void main(String[] args) {
        Sync sync = new Sync();
        newThread(sync, "t1111", 1000);
        newThread(sync, "t2222", 1000);
        newThread(sync, "t3333", 1000);
    }
}

利用AbstractQueuedSynchronizer簡單實現一個可重入的獨占鎖。

要實現獨占鎖，必須重寫tryAcquire和tryRelease方法。否則在獲取鎖和釋放鎖的時候，會拋出異常。
直接的調用AQS類的acquire(1)和release(1)方法獲取鎖和釋放鎖。

輸出結果是

線程t1111 開始運行，準備獲取鎖
====線程t1111 在run方法中獲取了鎖
====線程t1111  在lockAgain方法中再次獲取了鎖
線程t2222 開始運行，準備獲取鎖
線程t3333 開始運行，準備獲取鎖
----線程t1111 在lockAgain方法中釋放了鎖
----線程t1111 在run方法中釋放了鎖
====線程t2222 在run方法中獲取了鎖
====線程t2222  在lockAgain方法中再次獲取了鎖
----線程t2222 在lockAgain方法中釋放了鎖
----線程t2222 在run方法中釋放了鎖
====線程t3333 在run方法中獲取了鎖
====線程t3333  在lockAgain方法中再次獲取了鎖
----線程t3333 在lockAgain方法中釋放了鎖
----線程t3333 在run方法中釋放了鎖