// 定義一個資源池類
    class Pool {
        // 可用資源數(shù)100
        private static final int MAX_AVAILABLE = 100;
        // 定義信號量100
        private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
        // 獲取資源
        public Object getItem() throws InterruptedException {
            // 嘗試獲取
            available.acquire();
            // 返回可用資源
            return getNextAvailableItem();
        }
        // 釋放資源
        public void putItem(Object x) {
            // 如果資源標(biāo)記為未被使用
            if (markAsUnused(x))
            // 釋放資源
            available.release();
        }
        // Not a particularly efficient data structure; just for demo
        // 定義資源類型，可以是滿足業(yè)務(wù)的任何類型
        protected Object[] items = new Object[MAX_AVAILABLE] ... whatever kinds of items being managed
        // 是否被使用標(biāo)記
        protected boolean[] used = new boolean[MAX_AVAILABLE];
        // 獲取下一個可用資源
        protected synchronized Object getNextAvailableItem() {
            // 循環(huán)遍歷
            for (int i = 0; i < MAX_AVAILABLE; ++i) {
                // 如果未被使用
                if (!used[i]) {
                    // 使用標(biāo)記設(shè)置為true
                    used[i] = true;
                    // 返回當(dāng)前的資源
                    return items[i];
                }
            }
            return null; // not reached
        }
        // 標(biāo)記資源為未被使用
        protected synchronized boolean markAsUnused(Object item) {
            // 循環(huán)遍歷
            for (int i = 0; i < MAX_AVAILABLE; ++i) {
                // 找到需要釋放的資源
                if (item == items[i]) {
                    // 如果是被使用中
                    if (used[i]) {
                    // 使用標(biāo)記設(shè)置為false
                    used[i] = false;
                    // 返回true表示標(biāo)記成功
                    return true;
                } else
                    // 返回false表示標(biāo)記失敗
                    return false;
                }
            }
            return false;
        }
    }

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;
        // 構(gòu)造方法，調(diào)用父類AQS的setState方法，給共享變量state賦值
        // 即通過構(gòu)造方法給鎖的數(shù)量附初始值
        Sync(int permits) {
            setState(permits);
        }
        // 獲取鎖，也叫許可
        final int getPermits() {
            return getState();
        }
        // 共享模式下的非公平獲取
        // 此方法也體現(xiàn)出與ReentrantLock中Sync的實現(xiàn)不同
        // ReentrantLock中Sync是獨占模式下的獲取
        // 具體實現(xiàn)的不同體現(xiàn)在int remaining = available - acquires;
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                // 獲取鎖的可用數(shù)量
                int available = getState();
                // 可用數(shù)量 - 請求的數(shù)量（acquires默認(rèn)值為1） = 剩余量
                int remaining = available - acquires;
                // 如果remaining < 0即請求的鎖大于可用的數(shù)量，馬上返回負數(shù)，表示獲取鎖失敗
                if (remaining < 0 ||
                    // 否則通過CAS的方式將可用數(shù)量換成剩余量，并返回剩余量
                    // 自旋 + CAS 保證線程安全，線程不用排隊體現(xiàn)出非公平性
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
        // 共享模式下釋放鎖
        protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                // CAS修改鎖數(shù)量，成功則返回，失敗則繼續(xù)自旋
                if (compareAndSetState(current, next))
                    return true;
            }
        }
        // 根據(jù)指定的縮減量減小可用鎖的數(shù)目
        final void reducePermits(int reductions) {
            for (;;) {
                int current = getState();
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next))
                    return;
            }
        }
        // 獲取并返回立即可用的所有鎖
        final int drainPermits() {
            for (;;) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0))
                    return current;
            }
        }
    }

static final class NonfairSync extends Sync {
        private static final long serialVersionUID = -2694183684443567898L;
        // 構(gòu)造方法初始化鎖數(shù)量
        NonfairSync(int permits) {
            super(permits);
        }
        // 直接調(diào)用nonfairTryAcquireShared方法，走非公平策略
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

static final class FairSync extends Sync {
        private static final long serialVersionUID = 2014338818796000944L;
        // 構(gòu)造方法初始化鎖數(shù)量
        FairSync(int permits) {
            super(permits);
        }
        // 共享模式下的公平策略獲取
        // 與非公平策略唯一的不同體現(xiàn)在線程是否需要排隊
        // 即是否調(diào)用hasQueuedPredecessors()方法進行判斷
        // 如果需要排隊則立即返回繼續(xù)排隊
        // 否則通過CAS方式獲取鎖并返貨鎖的剩余量，結(jié)束自旋
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
    }

public class Semaphore implements java.io.Serializable {
    private static final long serialVersionUID = -3222578661600680210L;
    /** All mechanics via AbstractQueuedSynchronizer subclass */
    // 同步隊列
    private final Sync sync;
    // 構(gòu)造方法初始話鎖數(shù)量
    // 默認(rèn)采用非公平策略
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    // 構(gòu)造方法，帶一個布爾參數(shù)，true表示采用公平策略，false表示采用非公平策略
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }
}

// Semaphore
public void acquire() throws InterruptedException {
        // 調(diào)用sync的acquireSharedInterruptibly,即響應(yīng)中斷的獲取
        // 因為sync繼承AbstractQueuedSynchronizer
        // 即調(diào)用AQS的acquireSharedInterruptibly
        sync.acquireSharedInterruptibly(1);
    }
// 進入AQS
public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        // 如果線程被中斷，則響應(yīng)中斷
        if (Thread.interrupted())
            throw new InterruptedException();
        // 否則調(diào)用tryAcquireShared，如果獲取的鎖小于0即獲取鎖失敗則調(diào)用doAcquireSharedInterruptibly方法，進入同步隊列排隊
        // 如果獲取鎖成功則不排隊，走業(yè)務(wù)邏輯
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }
// Semaphore 中tryAcquireShared的實現(xiàn)
// 公平策略
protected int tryAcquireShared(int acquires) {
            for (;;) {
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }
// 非公平策略
protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
// 前面已經(jīng)解析過，不在贅述
 

// Semaphore
public void release() {
        sync.releaseShared(1);
    }
// 進入AQS
public final boolean releaseShared(int arg) {
        // 嘗試釋放鎖, 如果釋放鎖成功
        if (tryReleaseShared(arg)) {
            // 線程出同步隊列，返回true
            doReleaseShared();
            return true;
        }
        // 否則返回false
        return false;
    }
// Semaphore 中tryReleaseShared實現(xiàn)
protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                int current = getState();
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                if (compareAndSetState(current, next))
                    return true;
            }
        }