探索抽象同步隊列 AQS_ZenDei技術網路在線

AbstractQueuedSynchronizer抽象同步隊列簡稱AQS，它是實現同步器的基礎組件，併發包中鎖的底層就是使用AQS實現的。大多數開發者可能永遠不會直接使用AQS，但是知道其原理對於架構設計還是很有幫助的。 ...

by emanjusaka from https://www.emanjusaka.top/archives/8 彼岸花開可奈何
本文歡迎分享與聚合，全文轉載請留下原文地址。

前言

AbstractQueuedSynchronizer抽象同步隊列簡稱AQS，它是實現同步器的基礎組件，併發包中鎖的底層就是使用AQS實現的。大多數開發者可能永遠不會直接使用AQS，但是知道其原理對於架構設計還是很有幫助的。AQS是Java中的一個抽象類，全稱是AbstractQueuedSynchronizer，即抽象隊列同步器。它定義了兩種資源共用模式：獨占式和共用式。獨占式每次只能有一個線程持有鎖，例如ReentrantLock實現的就是獨占式的鎖資源；共用式允許多個線程同時獲取鎖，併發訪問共用資源，ReentrantReadWriteLock和CountDownLatch等就是實現的這種模式。AQS維護了一個volatile的state變數和一個FIFO（先進先出）的隊列。其中state變數代表的是競爭資源標識，而隊列代表的是競爭資源失敗的線程排隊時存放的容器。

一、原理

AQS的核心思想是通過一個FIFO的隊列來管理線程的等待和喚醒，同時維護了一個state變數來表示同步狀態，可以通過getState、setState、compareAndSetState函數修改其值。當一個線程想要獲取鎖時，如果state為0，則表示該線程獲取鎖成功，否則表示該線程獲取鎖失敗。它將被放入等待隊列中，直到滿足特定條件才能再次嘗試獲取。當一個線程釋放鎖時，如果state為1，則表示該線程釋放鎖成功，否則表示該線程釋放鎖失敗。AQS通過CAS操作來實現加鎖和解鎖。

1.1 CLH隊列

AQS中的CLH隊列鎖是CLH鎖的一種變體，將自旋操作改成了阻塞線程操作。AQS 中的對 CLH 鎖數據結構的改進主要包括三方面：擴展每個節點的狀態、顯式的維護前驅節點和後繼節點以及諸如出隊節點顯式設為 null 等輔助 GC 的優化。

在 AQS（AbstractQueuedSynchronizer）中使用的 CLH 隊列，head 指針和 tail 指針分別指向 CLH 隊列中的兩個關鍵節點。

head 指針：head 指針指向 CLH 隊列中的首個節點，該節點表示當前持有鎖的線程。當一個線程成功地獲取到鎖時，它就成為了持有鎖的線程，並且會將該信息記錄在 head 指針所指向的節點中。
tail 指針：tail 指針指向 CLH 隊列中的最後一個節點，該節點表示隊列中最後一個等待獲取鎖的線程。當一個線程嘗試獲取鎖時，它會生成一個新的節點，並將其插入到 CLH 隊列的尾部，然後成為 tail 指針所指向的節點。這樣，tail 指針的作用是標記當前 CLH 隊列中最後一個等待獲取鎖的線程。

通過 head 指針和 tail 指針，CLH 隊列能夠維護一種有序的等待隊列結構，保證線程獲取鎖的順序和互斥訪問的正確性。當一個線程釋放鎖時，它會修改當前節點的狀態，並喚醒後繼節點上的線程，讓後續的線程能夠及時感知鎖的釋放，並爭奪獲取鎖的機會。

1.2 線程同步

對於AQS來說，線程同步的關鍵是對狀態值state進行操作。state為0時表示沒有線程持有鎖，大於0時表示有線程持有鎖。根據state是否屬於一個線程，操作state的方式分為獨占方式和共用方式。

在獨占方式下獲取和釋放資源使用的方法為：

void acquire（int arg）
void acquireInterruptibly（int arg）
boolean release（int arg）

使用獨占方式獲取的資源是與具體線程綁定的，就是說如果一個線程獲取到了資源，就會標記是這個線程獲取到了，其他線程再嘗試操作state獲取資源時會發現當前該資源不是自己持有的，就會在獲取失敗後被阻塞。

在共用方式下獲取和釋放資源的方法為：

void acquireShared（int arg）
voidacquireSharedInterruptibly（int arg）
boolean releaseShared（int arg）。

對應共用方式的資源與具體線程是不相關的，當多個線程去請求資源時通過CAS方式競爭獲取資源，當一個線程獲取到了資源後，另外一個線程再次去獲取時如果當前資源還能滿足它的需要，則當前線程只需要使用CAS方式進行獲取即可。

二、資源獲取與釋放

2.1 獨占式

當一個線程調用acquire（int arg）方法獲取獨占資源時，會首先使用tryAcquire方法嘗試獲取資源，具體是設置狀態變數state的值，成功則直接返回，失敗則將當前線程封裝為類型為Node.EXCLUSIVE的Node節點後插入到AQS阻塞隊列的尾部，並調用LockSupport.park（this）方法掛起自己。
```
    public final void acquire(int arg) {
      if (! tryAcquire(arg) &&
          acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
          selfInterrupt();
   }
```

當一個線程調用release（int arg）方法時會嘗試使用tryRelease操作釋放資源，這裡是設置狀態變數state的值，然後調用LockSupport.unpark（thread）方法激活AQS隊列裡面被阻塞的一個線程（thread）。被激活的線程則使用tryAcquire嘗試，看當前狀態變數state的值是否能滿足自己的需要，滿足則該線程被激活，然後繼續向下運行，否則還是會被放入AQS隊列並被掛起。
```
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h ! = null && h.waitStatus ! = 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }
```

2.2 共用式

當線程調用acquireShared（int arg）獲取共用資源時，會首先使用tryAcquireShared嘗試獲取資源，具體是設置狀態變數state的值，成功則直接返回，失敗則將當前線程封裝為類型為Node.SHARED的Node節點後插入到AQS阻塞隊列的尾部，並使用LockSupport.park（this）方法掛起自己。
```
    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }
```

當一個線程調用releaseShared（int arg）時會嘗試使用tryReleaseShared操作釋放資源，這裡是設置狀態變數state的值，然後使用LockSupport.unpark（thread）激活AQS隊列裡面被阻塞的一個線程（thread）。被激活的線程則使用tryReleaseShared查看當前狀態變數state的值是否能滿足自己的需要，滿足則該線程被激活，然後繼續向下運行，否則還是會被放入AQS隊列並被掛起。
```
    public final boolean releaseShared(int arg) {
          if (tryReleaseShared(arg)) {
              doReleaseShared();
              return true;
          }
          return false;
      }
```

三、基於AQS實現自定義同步器

基於AQS實現一個不可重入的獨占鎖，自定義AQS需要重寫一系列函數，還需要定義原子變數state的含義。這裡定義，state為0表示目前鎖沒有被線程持有，state為1表示鎖已經被某一個線程持有，由於是不可重入鎖，所以不需要記錄持有鎖的線程獲取鎖的次數。

package top.emanjusaka;

import java.io.Serializable;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class UnReentrantLock implements Lock, Serializable {
    // 藉助 AbstractQueuedSynchronizer 實現
    private static class Sync extends AbstractQueuedSynchronizer {
        // 查看是否有線程持有鎖
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }
        // 嘗試獲取鎖
        public boolean tryAcquire(int acquires) {
            assert acquires == 1;
            // 使用CAS 設置state
            if (compareAndSetState(0, 1)) {
                // 如果 CAS 操作成功，表示成功獲得了鎖。這時，通過 setExclusiveOwnerThread 方法將當前線程設置為獨占鎖的擁有者
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            // 如果 CAS 操作失敗，即無法將 state 的值從 0 設置為 1，表示鎖已被其他線程占用，無法獲取鎖，於是返回 false。
            return false;
        }
        // 嘗試釋放鎖
        protected boolean tryRelease(int releases) {
            assert releases == 1;
            if (getState() == 0)
                throw new IllegalMonitorStateException();
            // 釋放成功，將獨占鎖的擁有者設為null
            setExclusiveOwnerThread(null);
            // 將state的值設為0
            setState(0);
            return true;
        }

        Condition newCondition() {
            return new ConditionObject();
        }
    }

    private final Sync sync = new Sync();

    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    public boolean isLocked() {
        return sync.isHeldExclusively();
    }

    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

}

在釋放鎖時並沒有使用 CAS（Compare and Swap）操作，而是直接使用了 setState 方法來將 state 的值設置為 0。

這是因為在釋放鎖的過程中，並不需要涉及到多線程併發的問題。只有持有鎖的線程才能夠釋放鎖，其他線程無法對鎖進行操作。因此，不需要使用 CAS 來進行原子性的狀態更新。

在這種情況下，可以直接使用普通的方法來設置 state 的值為 0，將獨占鎖的擁有者設為 null。因為只有一個線程可以操作這個鎖，不存在併發競爭的情況，也就不需要使用 CAS 來保證原子性。

需要註意的是，當調用 tryRelease 方法時，應該保證當前線程是持有鎖的線程，否則會拋出 IllegalMonitorStateException 異常。這是為了確保只有擁有鎖的線程才能釋放鎖，防止誤釋放其他線程的鎖。

四、參考資料

《併發編程之美》
AbstractQueuedSynchronizer抽象類的源碼

本文原創，才疏學淺，如有紕漏，歡迎指正。尊貴的朋友，如果本文對您有所幫助，歡迎點贊，並期待您的反饋，以便於不斷優化。
原文地址： https://www.emanjusaka.top/archives/8
微信公眾號：emanjusaka的編程棧