@Slf4j
public class ShareLock {

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

        private int lockCount;

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

        /**
         * 嘗試獲取共享鎖
         *
         * @param arg 每次獲取鎖的數(shù)量
         * @return 返回正數(shù)，表示后續(xù)其他線程獲取共享鎖可能成功； 返回0，表示后續(xù)其他線程無法獲取共享鎖；返回負(fù)數(shù)，表示當(dāng)前線程獲取共享鎖失敗
         */
        @Override
        protected int tryAcquireShared(int arg) {
            // 自旋
            for (;;) {
                int c = getState();
                // 如果持有鎖的數(shù)量大于指定數(shù)量，返回-1，線程進入阻塞
                if(c >= lockCount) {
                    return -1;
                }
                int nextc = c + 1;
                // cas設(shè)置成功，返回1，獲取到共享鎖
                if (compareAndSetState(c, nextc)) {
                    return 1;
                }
            }
        }

        /**
         * 嘗試釋放共享鎖
         *
         * @param arg 釋放鎖的數(shù)量
         * @return 如果釋放后允許喚醒后續(xù)等待結(jié)點返回true，否則返回false
         */
        @Override
        protected boolean tryReleaseShared(int arg) {
            // 自旋操作
            for (; ; ) {
                int c = getState();
                // 如果沒有鎖了
                if (c == 0) {
                    return false;
                }
                // 否則鎖量-1
                int nextc = c - 1;
                // cas修改狀態(tài)
                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 {
    //共享模式下的等待標(biāo)記
    static final Node SHARED = new Node();
    //獨占模式下的等待標(biāo)記
    static final Node EXCLUSIVE = null;
    //表示當(dāng)前結(jié)點已取消調(diào)度。當(dāng)timeout或被中斷（響應(yīng)中斷的情況下），會觸發(fā)變更為此狀態(tài)，進入該狀態(tài)后的結(jié)點將不會再變化。
    static final int CANCELLED =  1;
    //表示后繼結(jié)點在等待當(dāng)前結(jié)點喚醒。后繼結(jié)點入隊時，會將前繼結(jié)點的狀態(tài)更新為SIGNAL。
    static final int SIGNAL    = -1;
    //表示結(jié)點等待在Condition上，當(dāng)其他線程調(diào)用了Condition的signal()方法后，CONDITION狀態(tài)的結(jié)點將從等待隊列轉(zhuǎn)移到同步隊列中，等待獲取同步鎖。
    static final int CONDITION = -2;
    //共享模式下，前繼結(jié)點不僅會喚醒其后繼結(jié)點，同時也可能會喚醒后繼的后繼結(jié)點。
    static final int PROPAGATE = -3;
    //狀態(tài)，包括上面的四種狀態(tài)值，初始值為0，一般是節(jié)點的初始狀態(tài)
    volatile int waitStatus;
    //上一個節(jié)點的引用
    volatile Node prev;
    //下一個節(jié)點的引用
    volatile Node next;
    //保存在當(dāng)前節(jié)點的線程引用
    volatile Thread thread;
    //condition隊列的后續(xù)節(jié)點
    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);
    //是否成功標(biāo)志
    boolean failed = true;
    try {
        //等待過程中是否被中斷過的標(biāo)志
        boolean interrupted = false;
        // 自旋操作
        for (;;) {
            // 獲取前驅(qū)節(jié)點
            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;
                }
            }

            //判斷狀態(tài)，尋找安全點，進入waiting狀態(tài)，等著被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);
     //如果還有剩余量，繼續(xù)喚醒下一個鄰居線程
    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)) {
        //喚醒后繼結(jié)點
        doReleaseShared();
        return true;
    }
    return false;
}

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