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

技术分享 2周前 (11-11) 0 999+

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：公平模式。线程获取许可遵循队列顺序。

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()：尝试获取许可，但不阻塞。

Semaphore semaphore = new Semaphore(3); // 初始许可数为 3  // 获取许可，若无可用许可则阻塞 semaphore.acquire();        // 释放许可 semaphore.release();  // 尝试获取许可，若不可用立即返回 false，不会阻塞 if (semaphore.tryAcquire()) {     // do something }

acquire() 源码

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

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

release() 源码

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

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

四、Semaphore 的应用场景

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

1. 连接池限流

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

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();     } }