深入解析Java并发包(JUC)中的Semaphore

public class Semaphore implements java.io.Serializable {
    // 当前的许可数
    private final Sync sync;

    // 构造函数，创建一个具有给定许可数的Semaphore，默认非公平策略
    public Semaphore(int permits) {
        sync = new Sync(permits);
    }

    // 构造函数，创建一个具有给定许可数的Semaphore，并指定公平策略
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

    // 获取一个许可，如果当前没有可用许可，则等待
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 释放一个许可
    public void release() {
        sync.releaseShared(1);
    }

    // ... 其他方法，如acquire(int), release(int), tryAcquire(), tryRelease(), drainPermits()等

    // 同步器抽象类
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 返回当前许可数
        final int getPermits() {
            return getState();
        }

        // ... 其他方法，如tryAcquireShared(), tryReleaseShared()等

        // 提供给子类实现的公平锁和非公平锁
        // 这些方法需要由子类根据公平策略来实现
        protected abstract boolean tryAcquireShared(int acquires);
        protected abstract boolean tryReleaseShared(int releases);

        // 减少许可数
        final void reducePermits(int reductions) {
            // ... 实现细节
        }

        // ... 其他方法
    }

    // 非公平同步器
    static final class NonfairSync extends Sync {
        // ... 实现tryAcquireShared()等方法
    }

    // 公平同步器
    static final class FairSync extends Sync {
        // ... 实现tryAcquireShared()等方法，保证FIFO顺序
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    // 定义一个Semaphore，初始许可数为3
    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 模拟5个线程尝试访问一个只允许3个并发访问的资源
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            executor.execute(() -> {
                try {
                    // 获取一个许可
                    semaphore.acquire();
                    accessResource(threadId);
                    // 访问完成后释放许可
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 关闭线程池（这在实际应用中通常会在所有任务完成后进行）
        // executor.shutdown();
    }

    // 模拟访问资源的方法
    private static void accessResource(int threadId) throws InterruptedException {
        System.out.println("线程 " + threadId + " 获取到许可，开始访问资源。");
        // 模拟资源访问时间
        Thread.sleep(1000);
        System.out.println("线程 " + threadId + " 访问资源结束，释放许可。");
    }
}