AQS深入剖析實現原理

AQS(AbstractQueueSynchronizer)

概念

• AQS是什麼？

從全稱可以看出，它是一個抽象類，並且內部由一個雙向鏈表結構提供的FIFO隊列(CLH)存放因沒有獲取到資源的線程

• AQS作用？

在多線程環境下，爲了保證共享資源安全的使用，以及線程之間的同步，java提供了一個AQS供其子類擴展。

例如ReentrantLock就是一種排他鎖，保證僅有一個線程獲取鎖資源進入同步塊執行代碼，其他未獲取鎖線程阻塞起來等待被喚醒。

CountDownLath/Semaphore/CyclicBarrier/ReentrantReadWriteLock 是一種共享鎖，允許多個線程一起共享資源

AbstractQueueSynchronizer類內部組成

private transient volatile Node head;//隊列頭
   
private transient volatile Node tail;//隊列尾
   
private volatile int state;//同步狀態，互斥鎖state只有0和1 共享鎖state表示可共享資源個數
//隊列中節點類   
static final class Node {
   //當前線程中的狀態 -1表示後繼節點中的線程需要被unpark也就是從阻塞中喚醒
   //1 CANCELLED 表示取消 線程中斷或等待超時
   //-2 CONDITION 表示當前線程正在等待其他線程調用signal喚醒
   //-3 PROPAGATE 共享模式下釋放資源時，依次喚醒多個阻塞的線程
	volatile int waitStatus;
   volatile Node prev;
   volatile Node next;
   //阻塞的線程
   volatile Thread thread;
   //當線程獲取排他鎖時調用codition.await()就會將線程進入等待隊列中，當其他線程獲取到排他鎖調用signal時纔會將等待隊列中的線程轉移到同步鎖隊列中，讓此線程重新競爭鎖資源
   Node nextWaiter;
}

//以下爲抽象方法，提供給子類實現，利用是抽象模板模式，AQS會調用tryAccquire*方法，由子類提供具體邏輯，AQS會根據tryAccquire返回結果判斷是否需要將該線程放入隊列中阻塞起來
//排他模式
protect boolean tryAcquire(int arg);
protect boolean tryRelease (int arg);

//共享模式
protected int tryAcquireShared(int arg)
protected boolean tryReleaseShared(int arg)

AQS通過一個循環使用CAS保證一個節點能在多線程環境下進入同步隊列中，爲了避免線程未獲取到資源時直接阻塞起來，而是多次調用tryAcquire方法，當方法返回true時則表示獲取到資源，否則會阻塞線程

總結：

AQS提供了存放未獲取資源的線程和當資源可用時喚醒線程邏輯，具體是否需要阻塞和是否需要喚醒其他線程實現在子類中實現的。

AQS涉及到CAS+同步隊列、條件隊列

ReentrantLock

類結構

ReentrantLock類中使用到FairSync和NonFairSync，表示公平鎖和非公平鎖，其都是繼承於Sync類，而Sync就是繼承於AbstractQueueSync,下面會解釋鎖公平鎖和非公平鎖爲什麼不同。

非公平加鎖流程

加鎖的時序圖

  static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    final void lock() {
    //通過CAS競爭鎖，如果獲取鎖成功則將排他鎖擁有者設置爲當前線程
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);//調用AQS中的acquire方法
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

AQS中的acquire方法

 1、調用子類重寫的tryAcquire方法，返回true表示獲取鎖成功進入同步塊，返回false進入2
 2、調用addWaiter方法創建一個節點，通過CAS將該節點插入到隊尾
 3、acquireQueued 將未獲取到資源的線程阻塞
 
 
  public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

NonFairSync中的tryAcquire方法

      protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

NonFairSync的父類中的nonfairTryAcquire方法

   final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
            //CAS競爭鎖
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果同步獲取鎖的線程和當前佔用鎖的線程相同時無需額外同步直接獲取，就是鎖重入，所以lock和unlock必須要成對出現
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

AQS.addWaiter 將節點放入隊列中

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // 嘗試快速在隊尾加入該節點，但是有可能其他線程已經捷足先登了，將tail指針指向新的節點，那麼就會導致CAS失敗，則進入enq方法
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

AQS.enq 使用一個循環通過CAS操作直到將節點追加到隊尾

private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // 鏈表頭節點並不是一開始就創建的，而是當有節點入隊時纔會生成 
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

AQS.acquireQueued 方法

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                //如果當前節點前驅節點是頭節點，並且嘗試獲取鎖成功則將該節點升級爲head節點表示head節點爲當前運行的線程
                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);
        }
    }

AQS.shouldParkAfterFailedAcquire 方法

//保證將要阻塞的線程前驅節點的waitStatus=-1纔會將當前線程阻塞起來,並將已經取消的節點移除
 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
          
            return true;
        if (ws > 0) {
            
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
          、
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

AQS.parkAndCheckInterrupt

 //將線程park，直到獲取資源線程調用unlock操作，將阻塞的線程喚醒重新獲取鎖資源
  private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

非公平釋放鎖

在ReentrantLock中的unlock方法使用了幫助類Sync的relase方法(實際上是AQS中release方法，因爲Sync繼承了AQS類)

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

AQS.release()

public final boolean release(int arg) {
//實際上調用子類中實現的tryRelease方法，若返回true表示需要喚醒同步隊列中阻塞的線程
        if (tryRelease(arg)) {
            Node h = head;
            //只有當head節點不是null並且等待狀態不是初始值時
            if (h != null && h.waitStatus != 0)
            //喚醒阻塞的線程
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

Sync.tryRelease

 //如果當前線程和佔用鎖的線程不同的話會拋出IllegalMonitorStateException異常，可以看到此方法並沒有使用CAS操作保證線程安全，因爲在加鎖的時候只保證了一個線程獲取鎖，當然釋放鎖的時候也是隻有一個線程的
 protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //當state值爲0時表示當前線程已經釋放完了鎖
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

AQS.unparkSuccessor

private void unparkSuccessor(Node node) {
       
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            //從隊尾向前掃描找到最前面一個狀態不是CANCELLED的節點，並取出該節點thread喚醒，然後改線程從阻塞的地方繼續往下執行循環獲取鎖，若競爭鎖失敗還是會將該線程阻塞起來
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

兩個線程 T1 T2 T3競爭鎖資源時，當T1成功獲取鎖資源了，則以下是同步隊列中節點狀態變化圖

當T2線程未獲取到資源時，首先會創建Node node，該節點中包含T2線程對象的引用，當前head指向null那麼就會創建一個head節點，然後node節點插入到對尾

公平鎖和非公平鎖區別

優缺點

公平鎖防止線程餓死，但是吞吐量和系統響應時間會降低，當有個線程獲取鎖時執行時間很長時導致佔用鎖時間很長，影響其他執行時間很多線程獲取

非公平鎖會導致其他線程長時間獲取不到鎖，吞吐量和響應時間都會大大提高

實現方式上

公平鎖和非公平鎖在tryAcquire方法上實現不同

公平鎖的實現是當發現當前有同步隊列時，就會讓線程進入同步隊列排隊，等待被喚醒競爭鎖

非公平鎖的實現是不管有其他線程在等待獲取鎖，而是每次都會使用CAS競爭鎖