源碼分析之AbstractQueuedSynchronizer

時間 2019-11-16

標籤源碼分析 abstractqueuedsynchronizer 简体版

原文原文鏈接

在java.util.concurrent包中，大部分的同步器都是基於AbstractQueuedSynchronizer(AQS)這個框架實現的。這個框架爲同步狀態提供原子性管理、線程的阻塞和解除阻塞以及排隊提供了一種通用機制。java

同步器通常包含2種方法，一種是acquire，另外一種是release。acquire操做阻塞線程，獲取鎖。release經過某種方式改變讓被acquire阻塞的線程繼續執行，釋放鎖。爲了實現這2種操做，須要如下3個基本組件的相互協做：node

同步狀態的原子性管理
線程的阻塞和解除阻塞
隊列管理

同步狀態

/** * The synchronization state. */
    private volatile int state;複製代碼

AQS使用一個int變量來保存同步狀態，並暴露出getState、setState以及compareAndSet來讀取或更新這個狀態。而且用了volatile來修飾，保證了在多線程環境下的可見性。經過使用compare-and-swap(CAS)指令來實現compareAndSetState。api

這裏的同步狀態用int而非long，主要是由於64位long字段的原子性操做在不少平臺上是使用內部鎖的方式來模擬實現的，這會使得同步器的會有性能問題。絕對多數int型的state足夠咱們使用，但JDK也提供了long型state的實現：java.util.concurrent.locks.AbstractQueuedLongSynchronizer。安全

阻塞

JDK1.5以前，阻塞線程和解除線程阻塞都是基於Java自身的監控器。在AQS中實現阻塞是用java.util.concurrent包的LockSuport類。方法LockSupport.park阻塞當前線程，直到有個LockSupport.unpark方法被調用。多線程

隊列管理

AQS框架關鍵就在於如何管理被阻塞的線程隊列。提供了2個隊列，分別是線程安全Sync Queue(CLH Queue)、普通的Condition Queue。併發

Sync Queue

Sync Queue是基於FIFO的隊列，用於構建鎖或者其餘相關同步裝置。CLH鎖能夠更容易地去實現取消（cancellation）和超時功能，所以咱們選擇了CLH鎖做爲實現的基礎。框架

隊列中的元素Node是保存線程的引用和線程狀態。Node是AQS的一個靜態內部類：性能

static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;
    }複製代碼

Node類的成員變量如上所示，主要負責保存線程引用、隊列的前繼和後繼節點，以及同步狀態：ui

成員	描述
waitStatus	用來標記Node的狀態: CANCELLED:1, 表示當前線程已經被取消 SIGNAL:-1,表示當前節點的後繼節點等待運行 CONDITION:-2, 表示當前節點已被加入Condition Queue PROPAGATE:-3, 共享鎖的最終狀態是PROPAGATE
thread	當前獲取lock的線程
SHARED	表示節點是共享模式
EXCLUSIVE	表示節點是獨佔模式
prev	前繼節點
next	後繼節點
nextWaiter	存儲Condition Queue中的後繼節點

Node元素是Sync Queue構建的基礎。當獲取鎖的時候，請求造成節點掛載在尾部。而鎖資源的釋放再獲取的過程是從開始向後進行的。
this

acquire 獲取鎖

在AQS自身僅定義了相似acquire方法。在實現鎖的時候，通常會實現一個繼承AQS的內部類Sync。而在Sync類中，咱們根據需求來實現重寫tryAcquire方法和tryRelease方法。獨佔鎖acquire方法以下：

public final void acquire(int arg) {

        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }複製代碼

經過tryAcquire（由不一樣的實現類實現）嘗試獲取鎖，若是能夠獲取鎖直接返回。獲取不到鎖，則調用addWaiter方法；

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
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }複製代碼

addWaiter方法做用是把當前線程封裝成Node節點，經過CAS操做快速嘗試掛載至隊列尾部。
- 若是tail節點t已經有了：將t節點更新爲當前節點node的前繼節點node.prev，將t.next更新爲當前節點node；
- 若是tail節點添加失敗：
  - 若是tail節點爲空，那麼原子化的分配一個頭節點，並將尾節點指向頭節點，這一步是初始化；
  - 若是tail節點不爲空，循環重複addWaiter方法的工做直至當前節點入隊爲止。

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }複製代碼

節點加入Sync Queue以後，接下來就是要進行鎖的獲取，或者說是訪問控制了，只有一個線程可以在同一時刻繼續的運行，而其餘的進入等待狀態。
- 獲取當前節點的前繼節點
- 當前繼節點是頭結點而且可以獲取狀態，表明該當前節點佔有鎖；若是知足上述條件，那麼表明可以佔有鎖，根據節點對鎖佔有的含義，設置頭結點爲當前節點。
- 不然進入等待狀態。

至此，能夠總結一次acquire的過程大體爲：

release 釋放鎖

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }複製代碼

首先經過CAS操做變動同步狀態state。
釋放成功後，經過LockSupport.unpark方法來喚醒後繼節點，後繼節點繼續獲取鎖。

Condition Queue

AQS框架提供了一個ConditionObject內部類，給維護獨佔同步的類以及實現Lock接口的類使用。一個鎖對象能夠關聯任意數目的條件對象，能夠提供典型的Java監視器風格的await、signal和signalAll操做，包括帶有超時的，以及一些檢測、監控的方法。Condition Queue是普通的隊列並不要求是線程安全，緣由是在線程在操做Condition時，要求線程必須獨佔鎖，不須要考慮併發的問題。

Condition Queue也是以Node爲基礎的隊列。

/** First node of condition queue. */
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        private transient Node lastWaiter;複製代碼

await操做

Condition在執行await操做時，首先會調用addConditionWaiter()方法將當前線程封裝的Node節點加入到wait queue。

private Node addConditionWaiter() {
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }複製代碼

上述addConditionWaiter的邏輯是：

首先清除Condition Queue隊列中cancelled狀態的尾節點；
如Condition Queue隊列爲空，封裝當前線程的node節點爲Condition Queue的firstWaiter。如Condition Queue隊列不爲空，則把該節點加至隊列尾部。

public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }複製代碼

加入Condition queue以後，要釋放當前線程獲取的全部的鎖；
若是線程沒有在Sync Queue中，將調用LockSupport.park阻塞當前線程，直到signalled或者interrupted喚醒去獲取鎖。

single 操做

public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }複製代碼

首先檢查線程是否獨佔鎖；
獲取Codition Queue的firstWaiter，將節點轉移至Sync Queue中去。

singleAll 操做

private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }複製代碼

signalAll喚醒Condition Queue的全部等待線程，將全部的Condition Queue中的node元素轉移至Sync Queue中去。