一文搞懂Java並行AQS的共用鎖模式

@Slf4j
public class ShareLock {

    /**
     * 共用鎖幫助類
     */
    private static class ShareSync extends AbstractQueuedSynchronizer {

        private int lockCount;

        /**
         * 建立共用鎖幫助類，最多有count把共用鎖，超過了則阻塞
         *
         * @param count 共用鎖數量
         */
        public ShareSync(int count) {
           this.lockCount = count;
        }

        /**
         * 嘗試獲取共用鎖
         *
         * @param arg 每次獲取鎖的數量
         * @return 返回正數，表示後續其他執行緒獲取共用鎖可能成功； 返回0，表示後續其他執行緒無法獲取共用鎖；返回負數，表示當前執行緒獲取共用鎖失敗
         */
        @Override
        protected int tryAcquireShared(int arg) {
            // 自旋
            for (;;) {
                int c = getState();
                // 如果持有鎖的數量大於指定數量，返回-1，執行緒進入阻塞
                if(c >= lockCount) {
                    return -1;
                }
                int nextc = c + 1;
                // cas設定成功，返回1，獲取到共用鎖
                if (compareAndSetState(c, nextc)) {
                    return 1;
                }
            }
        }

        /**
         * 嘗試釋放共用鎖
         *
         * @param arg 釋放鎖的數量
         * @return 如果釋放後允許喚醒後續等待結點返回true，否則返回false
         */
        @Override
        protected boolean tryReleaseShared(int arg) {
            // 自旋操作
            for (; ; ) {
                int c = getState();
                // 如果沒有鎖了
                if (c == 0) {
                    return false;
                }
                // 否則鎖量-1
                int nextc = c - 1;
                // cas修改狀態
                if (compareAndSetState(c, nextc)) {
                    return true;
                }
            }
        }
    }

    private final ShareSync sync;

    public ShareLock(int count) {
        this.sync = new ShareSync(count);
    }

    /**
     * 加共用鎖
     */
    public void lockShare() {
        sync.acquireShared(1);
    }

    /**
     * 釋放共用鎖
     */
    public void releaseShare() {
        sync.releaseShared(1);
    }
}

public static void main(String[] args) throws InterruptedException {
        ShareLock shareLock = new ShareLock(3);
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                shareLock.lockShare();
                try {
                    log.info("lock success");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    shareLock.releaseShare();
                    log.info("release success");
                }

            }, "thread-" + i).start();
        }
        Thread.sleep(10000);
    }

private transient volatile Node head;
private transient volatile Node tail;

static final class Node {
    //共用模式下的等待標記
    static final Node SHARED = new Node();
    //獨佔模式下的等待標記
    static final Node EXCLUSIVE = null;
    //表示當前結點已取消排程。當timeout或被中斷（響應中斷的情況下），會觸發變更為此狀態，進入該狀態後的結點將不會再變化。
    static final int CANCELLED =  1;
    //表示後繼結點在等待當前結點喚醒。後繼結點入隊時，會將前繼結點的狀態更新為SIGNAL。
    static final int SIGNAL    = -1;
    //表示結點等待在Condition上，當其他執行緒呼叫了Condition的signal()方法後，CONDITION狀態的結點將從等待佇列轉移到同步佇列中，等待獲取同步鎖。
    static final int CONDITION = -2;
    //共用模式下，前繼結點不僅會喚醒其後繼結點，同時也可能會喚醒後繼的後繼結點。
    static final int PROPAGATE = -3;
    //狀態，包括上面的四種狀態值，初始值為0，一般是節點的初始狀態
    volatile int waitStatus;
    //上一個節點的參照
    volatile Node prev;
    //下一個節點的參照
    volatile Node next;
    //儲存在當前節點的執行緒參照
    volatile Thread thread;
    //condition佇列的後續節點
    Node nextWaiter;
}

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

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();
            //如果到head的下一個，因為head是拿到資源的執行緒，此時node被喚醒，很可能是head用完資源來喚醒自己的
            if (p == head) {
                //嘗試獲取資源
                int r = tryAcquireShared(arg);
                //成功
                if (r >= 0) {
                    //將head指向自己，還有剩餘資源可以再喚醒之後的執行緒
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    //如果等待過程中被打斷過，此時將中斷補上。
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }

            //判斷狀態，尋找安全點，進入waiting狀態，等著被unpark()或interrupt()
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head;
    //head指向自己
    setHead(node);
     //如果還有剩餘量，繼續喚醒下一個鄰居執行緒
    if (propagate > 0 || h == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            // 喚醒操作
            doReleaseShared();
    }
}

public final boolean releaseShared(int arg) {
    //嘗試釋放資源
    if (tryReleaseShared(arg)) {
        //喚醒後繼結點
        doReleaseShared();
        return true;
    }
    return false;
}

private void doReleaseShared() {
    // 自旋操作
    for (;;) {
        // 獲取頭節點
        Node h = head;
        if (h != null && h != tail) {
            // 獲取節點的等待狀態
            int ws = h.waitStatus;
            // 如果節點等待狀態是-1， -1表示有責任喚醒後續節點的狀態
            if (ws == Node.SIGNAL) {
                // cas修改當前節點的等待狀態為0
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;
                //喚醒後續節點
                unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;
        }
        if (h == head)// head發生變化
            break;
    }
}