怎么從源碼看AQS

本篇內容介紹了“怎么從源碼看AQS”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

AQS實際上是操作以Node為元素的隊列，Node包含了所屬線程，先以不公平鎖分析：lock時先嘗試獲取鎖，獲取失敗則進入隊列且被阻塞（期間可以被打斷）等待，當鎖被釋放的時候，如果隊列不為空，則喚醒頭節點的下一個節點NEXT，如果此時被新線程NT拿到鎖，則NEXT繼續進入阻塞等待，當NT釋放鎖時，頭節點的下一個節點還是NEXT再次被喚醒，如果此時NEXT獲得鎖，則將NEXT設置為頭節點，這就是一個大概的流程，順著這個思路，再來一步步看實現代碼。

AQS->AbstractQueuedSynchronizer，看名字 抽象隊列同步器，首先得有隊列。

先來看隊列節點類，Node：

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;//取值為 上面的4個int，初始化為0

        volatile Node prev;//前一個節點

        volatile Node next;//下一個節點

        volatile Thread thread;

        Node nextWaiter;//下一個等待節點  SHARED，EXCLUSIVE 
        
        //如果節點在共享模式下等待，則返回true
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        //返回前一個節點
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {
        }
        //以下是Node的兩種不同的使用方式
        Node(Thread thread, Node mode) {  
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { 
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

注意上面兩種不同的節點使用方式，要構建隊列那么還得有 隊列的首尾表示節點，

    //隊列頭節點，除開初始化，只能通過setHead方法設置    
    private transient volatile Node head;
    //隊列尾節點，只能通過enq方法設置
    private transient volatile Node tail;
   //同步狀態
    private volatile int state; //初始狀態為0

那么具體的實現或者用法，我們還是通過舉例來說明：

ReentrantLock-可重入鎖，下面以RL代表 ，以AQS代表AbstractQueuedSynchronizer。

在RL中有個靜態內部類，Sync  是AbstractQueuedSynchronizer的抽象子類。在Sync的基礎上繼續擴展出兩個實現子類 NonfairSync（非公平）和FairSync（公平）。而RL實現鎖機制就是建立在 Sync的基礎之上的。

先說說NonfairSync（以nfs簡稱），非公平鎖：

當我們使用RL.lock()獲取鎖，實際調用是nfs的lock方法

final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

compareAndSetState就是使用CAS樂觀鎖來修改AQS的state值，由0 改為1，有疑問可以參考UnSafe類實現CAS樂觀鎖，然后將當前線程設置為鎖的占有線程。acquire方法是由AQS實現的，

//嘗試獲取鎖失敗，則進入隊列
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//如果在acquireQueued期間線程標記中斷，那么將進入線程中斷selfInterrupt。
            selfInterrupt();
    }

tryAcquire是由子類來實現的，這里也就是由nfs實現，主要是再次嘗試獲取鎖（可重入鎖），來看具體實現：

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { //如果state為0 ， 則嘗試獲取鎖
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果鎖已經被占用，但是占有者是當前線程，那么將state + 1，即重入鎖，最大值為Integer.MAX_VALUE
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) 
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;//否則返回false
        }

第二個條件 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，EXCLUSIVE獨占鎖標志，兩個方法都是AQS實現的：

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        //先判斷隊列的尾節點是否為空，此處是一個快速嘗試，失敗了就繼續走enq方法
        Node pred = tail;
        if (pred != null) {//嘗試將尾節點設置為node，設置成功則返回
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);//將node插入隊列尾部，然后返回，也是由CAS實現，注意 enq會初始化一個空的Node（無參構造函數）作為head節點
        return node;
    }
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //進入循環
            for (;;) {
                final Node p = node.predecessor();//獲取node的上一個節點p
                if (p == head && tryAcquire(arg)) {//如果p是頭節點，而且當前線程拿到了鎖，那么就將node設為頭節點，注意這里可能會有最新來的線程和p節點所屬的線程進行競爭，競爭失敗則繼續進入阻塞等待，當鎖被釋放時，又會喚醒頭節點的下一個節點
                    setHead(node);
                    p.next = null; // 方便回收
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())  //線程會阻塞，等待釋放，直到prev節點完全釋放鎖的時候會被喚醒，然后開始再次循環。shouldParkAfterFailedAcquire 主要是修改node的waitStatus。parkAndCheckInterrupt 主要阻塞當前線程，期間線程可能會被中斷，當線程被喚醒之后，再判斷是否被中斷。
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node); //取消獲得的鎖
        }
    }
//因為是普通節點，所以waitStatus的初始值為0，忘了的話可以回到上面看下Node的兩種構造函數
//所以這里主要由兩步，第一步嘗試將pred的 waitStatus 改為SIGNAL，第二次再進來就直接返回true了
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實現
public final boolean release(int arg) {
        if (tryRelease(arg)) { //由子類實現，包括重入鎖持有，直到所有鎖全部釋放
            Node h = head;
            if (h != null && h.waitStatus != 0) //如果head節點的等待狀態不為0，在獲取鎖失敗的時候，node節點會將prev的waitstatus改為SIGNAL，也就是p后面還有節點， 具體是在 shouldParkAfterFailedAcquire方法
                unparkSuccessor(h);//喚醒h的下一個節點
            return true;//完全釋放鎖
        }
        return false;
    }
//nfs實現：
protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread()) // 判斷當前線程是否是鎖的持有線程
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) { //如果c == 0表示當前線程獲得的重入鎖已經全部釋放，則修改鎖的持有線程為null
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);//否則只是將state - 1 
            return free;
        }

從上面加鎖、釋放鎖的步驟可以看出，不公平鎖不公平的地方在于，當head節點完全釋放鎖的時候，這個時候最新來的線程和head節點喚醒的下一個節點會同時競爭鎖。

“怎么從源碼看AQS”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！