一文彻底弄懂JUC工具包的Semaphore

Semaphore 是 Java 并发包 (java.util.concurrent) 中的重要工具，主要用于控制多线程对共享资源的并发访问量。它可以设置"许可证"（permit）的数量，并允许指定数量的线程同时访问某一资源，适合限流、资源池等场景。下面从源码设计、底层原理、应用场景、以及与其它 JUC 工具的对比来详细剖析 Semaphore。

一、Semaphore 的基本原理

Semaphore 本质上是一种计数信号量，内部维护一个许可计数，每个线程在进入时需要申请一个许可（acquire），完成后释放该许可（release）。当许可计数为零时，其他线程会阻塞，直到有线程释放许可。

1. 计数和许可

许可数：Semaphore 在初始化时设置许可数，通常表示可以同时访问资源的线程数量。
计数增减 ：调用 acquire() 时减少许可数，调用 release() 时增加许可数。
公平性：Semaphore 可以设置为"公平"模式，保证线程按 FIFO 顺序获得许可。默认是"非公平"模式，性能更高，但线程获取许可的顺序不保证。

二、底层实现与源码解析

Semaphore 基于 AbstractQueuedSynchronizer (AQS) 实现，其实现方式和 CountDownLatch 类似，但使用了 AQS 的共享模式，并对许可计数进行精确管理。

1. AQS 的共享模式

Semaphore 使用 AQS 的共享模式（Shared），其中 AQS 的 state 表示剩余许可数。acquireShared() 方法用于申请许可，releaseShared() 方法用于释放许可。

2. 内部类 Sync 的实现

Semaphore 的核心实现依赖于其内部类 Sync，Sync 是 AbstractQueuedSynchronizer 的子类。根据是否是公平模式，有两种实现：NonfairSync 和 FairSync。

NonfairSync ：非公平模式。线程调用 acquire 时直接尝试获取许可，不保证顺序。
FairSync：公平模式。线程获取许可遵循队列顺序。

java 复制代码

abstract static class Sync extends AbstractQueuedSynchronizer {
    Sync(int permits) {
        setState(permits);  // 设置初始许可数
    }

    final int getPermits() {
        return getState();
    }

    final int nonfairTryAcquireShared(int acquires) {
        for (;;) {
            int available = getState();
            int remaining = available - acquires;
            if (remaining < 0 || compareAndSetState(available, remaining))
                return remaining;
        }
    }

    protected final boolean tryReleaseShared(int releases) {
        for (;;) {
            int current = getState();
            int next = current + releases;
            if (compareAndSetState(current, next))
                return true;
        }
    }
}

非公平模式（nonfairTryAcquireShared） ：直接尝试获取许可，如果成功则更新 state。
公平模式（FairSync）：遵循 AQS 的队列顺序，确保 FIFO 访问。

三、Semaphore 的使用方法

Semaphore 提供了三种主要方法来操作许可：

acquire()：获取一个许可，若没有许可则阻塞。
release()：释放一个许可，唤醒等待的线程。
tryAcquire()：尝试获取许可，但不阻塞。

java 复制代码

Semaphore semaphore = new Semaphore(3); // 初始许可数为 3

// 获取许可，若无可用许可则阻塞
semaphore.acquire();      

// 释放许可
semaphore.release();

// 尝试获取许可，若不可用立即返回 false，不会阻塞
if (semaphore.tryAcquire()) {
    // do something
}

acquire() 源码

java 复制代码

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

acquireSharedInterruptibly(1) 会调用 nonfairTryAcquireShared(1) 或 tryAcquireShared（公平模式），尝试获取许可，若没有足够许可则阻塞等待。

release() 源码

java 复制代码

public void release() {
    sync.releaseShared(1);
}

releaseShared(1) 增加许可数并唤醒阻塞线程，使等待线程得以继续执行。

四、Semaphore 的应用场景

Semaphore 非常适合控制对有限资源的访问，典型的应用场景有：

1. 连接池限流

在数据库连接池中，可以使用 Semaphore 限制同时访问连接的线程数。例如，数据库连接数有限，通过 Semaphore 控制同时访问的线程数量，避免过度负载。

java 复制代码

public class DatabaseConnectionPool {
    private static final int MAX_CONNECTIONS = 5;
    private final Semaphore semaphore = new Semaphore(MAX_CONNECTIONS);

    public Connection getConnection() throws InterruptedException {
        semaphore.acquire();
        return acquireConnection();
    }

    public void releaseConnection(Connection conn) {
        releaseConnection(conn);
        semaphore.release();
    }
}

2. 控制线程并发数

在高并发任务中，Semaphore 可限制同时执行的线程数量，例如，控制下载任务的并发数，避免过多线程导致的系统负载过高。

3. 资源分配和限流

Semaphore 适合资源共享场景，如共享打印机、固定线程数的线程池等，确保资源不会被过度占用。

五、与其他 JUC 工具的对比

1. CountDownLatch

许可机制：Semaphore 的许可数可以动态变化，而 CountDownLatch 的计数器只能递减。
适用场景：Semaphore 控制并发资源访问数量，而 CountDownLatch 用于线程等待。

2. CyclicBarrier

作用：Semaphore 适合控制资源访问并发数，而 CyclicBarrier 则用于线程间的同步点，使所有线程达到某个屏障时一起继续。
灵活性 ：Semaphore 更灵活，可随时 release()，不必等待所有线程。

3. ReentrantLock

模式：ReentrantLock 是排他锁，每次只允许一个线程访问。Semaphore 允许多个线程共享资源（多个许可）。
适用场景：ReentrantLock 适合独占资源场景，Semaphore 适合资源池、限流等。

4. Phaser

复杂度：Phaser 用于复杂的多阶段同步，可以动态增加/减少线程，而 Semaphore 主要用于固定数量资源控制。
适用性：Phaser 适合分阶段任务同步，而 Semaphore 适合控制资源并发数。

庐山烟雨浙江潮，未至千般恨不消。

到得还来别无事，庐山烟雨浙江潮。

近半年不会再更新了，居家办公的日子要结束了。读书，世界就在眼前；不读书，眼前就是世界。与你共勉！