你好，我是你的 Java 并发小助手。今天我们来聊聊 Java 并发编程中一个非常重要的工具——Semaphore（信号量）。特别是，我们要深入探讨它的两种模式：公平模式和非公平模式，以及它们在不同业务场景下的性能差异。准备好你的咖啡，让我们开始吧！
1. 什么是 Semaphore？
Semaphore 是一种用于控制对共享资源的并发访问的同步工具。你可以把它想象成一个停车场，Semaphore 就像停车位的数量。线程就像车辆，它们需要在进入共享资源（停车场）之前获取一个许可（停车位）。如果许可数量用完了，线程就必须等待，直到有许可被释放。
Semaphore 的核心方法是：
acquire()：获取一个许可。如果许可不可用，则阻塞当前线程直到获取到许可。release()：释放一个许可，将许可返回给信号量。
2. 公平模式 vs. 非公平模式
Semaphore 提供了两种模式：
- 公平模式（Fair Mode）：线程按照请求的顺序获取许可。就像排队一样，先到先得。这保证了线程不会“饿死”，即长期无法获取许可。但在高并发环境下，公平模式的性能可能不如非公平模式。
- 非公平模式（Nonfair Mode）：线程可以尝试“插队”获取许可。当线程调用
acquire()时，它会首先尝试获取许可，如果可以立即获取，则直接获取。如果不能立即获取，才会加入等待队列。这种模式的优点是吞吐量高，但可能导致某些线程长时间无法获取许可，即“饥饿”现象。
2.1 代码示例：创建公平和非公平的 Semaphore
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
public static void main(String[] args) throws InterruptedException {
// 创建一个公平的 Semaphore，初始许可数量为 1
Semaphore fairSemaphore = new Semaphore(1, true);
// 创建一个非公平的 Semaphore，初始许可数量为 1
Semaphore nonFairSemaphore = new Semaphore(1, false);
System.out.println("Fair Semaphore: " + fairSemaphore.isFair()); // 输出 true
System.out.println("Non-fair Semaphore: " + !nonFairSemaphore.isFair()); // 输出 true
// 模拟线程访问共享资源
Thread fairThread1 = new Thread(() -> accessResource(fairSemaphore, "Fair Thread 1"));
Thread fairThread2 = new Thread(() -> accessResource(fairSemaphore, "Fair Thread 2"));
Thread nonFairThread1 = new Thread(() -> accessResource(nonFairSemaphore, "Non-fair Thread 1"));
Thread nonFairThread2 = new Thread(() -> accessResource(nonFairSemaphore, "Non-fair Thread 2"));
fairThread1.start();
fairThread2.start();
nonFairThread1.start();
nonFairThread2.start();
Thread.sleep(2000); // 稍作等待，让线程执行
}
static void accessResource(Semaphore semaphore, String threadName) {
try {
System.out.println(threadName + " is waiting for permit...");
semaphore.acquire(); // 获取许可
System.out.println(threadName + " acquired permit, processing...");
Thread.sleep(1000); // 模拟处理时间
System.out.println(threadName + " releasing permit...");
semaphore.release(); // 释放许可
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
}
}
在这个例子中，我们创建了两个 Semaphore，一个公平的，一个非公平的。我们创建了两个线程来尝试获取和释放许可。你可以运行这段代码，观察线程获取许可的顺序。在公平模式下，你会发现线程按照它们启动的顺序获取许可。而在非公平模式下，获取顺序可能是不确定的。
3. 性能差异分析
公平模式和非公平模式在性能上存在显著差异，主要体现在以下几个方面：
- 吞吐量（Throughput）：非公平模式通常具有更高的吞吐量。因为线程可以“插队”，减少了线程等待的时间。这使得系统可以处理更多的请求。
- 响应时间（Response Time）：非公平模式的平均响应时间可能更短，因为线程可以更快地获取许可。但是，某些线程的响应时间可能很长，甚至出现“饥饿”现象。
- 上下文切换（Context Switching）：公平模式需要维护一个等待队列，线程在获取许可时，可能需要进行上下文切换。而非公平模式减少了上下文切换的次数，提高了性能。
- 锁竞争（Lock Contention）：非公平模式下，线程可能会频繁地尝试获取许可，增加了锁竞争。但在高并发环境下，这种竞争带来的性能提升通常大于锁竞争带来的开销。
3.1 性能测试案例
为了更好地理解这两种模式的性能差异，我们可以进行一个简单的性能测试。我们可以编写一个程序，模拟多个线程并发访问共享资源，并使用不同的 Semaphore 模式。我们可以测量程序的吞吐量和响应时间。
import java.util.concurrent.Semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
public class SemaphorePerformanceTest {
private static final int NUM_THREADS = 100; // 线程数量
private static final int PERMITS = 10; // 许可数量
private static final int ITERATIONS = 1000; // 每个线程的迭代次数
public static void main(String[] args) throws InterruptedException {
// 测试公平 Semaphore
testSemaphore("Fair Semaphore", new Semaphore(PERMITS, true));
// 测试非公平 Semaphore
testSemaphore("Non-fair Semaphore", new Semaphore(PERMITS, false));
}
static void testSemaphore(String semaphoreType, Semaphore semaphore) throws InterruptedException {
long startTime = System.currentTimeMillis();
AtomicInteger counter = new AtomicInteger(0);
ExecutorService executor = Executors.newFixedThreadPool(NUM_THREADS);
for (int i = 0; i < NUM_THREADS; i++) {
executor.submit(() -> {
for (int j = 0; j < ITERATIONS; j++) {
try {
semaphore.acquire(); // 获取许可
// 模拟处理时间
Thread.sleep(1); // 模拟 1ms 的处理时间
semaphore.release(); // 释放许可
counter.incrementAndGet();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
}
}
});
}
executor.shutdown();
executor.awaitTermination(1, TimeUnit.MINUTES);
long endTime = System.currentTimeMillis();
long duration = endTime - startTime;
System.out.println(semaphoreType + " - Total operations: " + counter.get() + ", Duration: " + duration + " ms, Throughput: " + (double) counter.get() / duration * 1000 + " ops/s");
}
}
在这个测试中，我们使用固定数量的线程并发访问共享资源，并测量程序的吞吐量。运行这段代码，你会发现非公平模式的吞吐量通常高于公平模式。
4. 应用场景选择
选择公平模式还是非公平模式，取决于你的具体应用场景：
公平模式适用场景：
- 需要保证线程获取资源的顺序：例如，在某些资源分配场景中，需要按照请求的顺序分配资源，以避免“饿死”某些线程。
- 对响应时间有较高要求：虽然非公平模式的平均响应时间可能更短，但在某些情况下，公平模式可以避免某些线程长时间等待，从而保证整体的响应时间。
- 资源竞争不激烈：如果资源竞争不激烈，公平模式的性能损失可以忽略不计，并且可以保证线程的公平性。
非公平模式适用场景：
- 高并发场景：在高并发场景下，非公平模式的吞吐量更高，可以处理更多的请求。
- 对吞吐量有较高要求：如果你的应用需要处理大量的请求，并且对吞吐量有较高的要求，非公平模式是更好的选择。
- 可以容忍“饥饿”现象：在某些场景下，可以容忍某些线程长时间无法获取资源，例如，某些后台任务或者不太重要的任务。
4.1 具体应用场景举例
- 数据库连接池：
- 公平模式：在某些情况下，你可能需要保证数据库连接的公平分配，以避免某些线程长时间无法获取连接。
- 非公平模式：在高并发场景下，非公平模式可以提高连接池的吞吐量，更快地处理数据库请求。
- 线程池：
- 公平模式：在某些情况下，你可能需要保证任务的公平执行顺序。
- 非公平模式：通常，线程池使用非公平模式可以提高任务处理的效率。
- 资源限流：
- 非公平模式：用于限制对某个资源的并发访问，提高系统的吞吐量和响应速度。
5. 深入理解原理
为了更好地理解 Semaphore 的工作原理，我们需要了解其底层的实现细节。
5.1 Semaphore 的内部结构
Semaphore 内部维护了一个计数器，用于表示当前可用的许可数量。acquire() 方法会尝试获取许可，如果计数器大于 0，则减 1，并立即返回。如果计数器等于 0，则阻塞当前线程，并将线程加入等待队列。release() 方法会释放一个许可，将计数器加 1，并唤醒等待队列中的一个线程。
5.2 公平模式的实现
公平模式通过维护一个 FIFO（先进先出）的等待队列来实现。当线程调用 acquire() 方法时，它会被加入到等待队列的尾部。release() 方法会从等待队列的头部获取一个线程，并唤醒它。这种实现保证了线程按照请求的顺序获取许可。
5.3 非公平模式的实现
非公平模式在 acquire() 方法中首先尝试获取许可。如果可以立即获取，则直接获取，无需加入等待队列。只有当无法立即获取时，才将线程加入等待队列。这种实现减少了锁竞争和上下文切换的次数，提高了吞吐量。
5.4 底层实现细节 (JDK 源码分析)
让我们简要地分析一下 JDK 中 Semaphore 的实现（基于 JDK 17）：
public class Semaphore implements java.io.Serializable {
private final Sync sync;
public Semaphore(int permits) {
sync = new NonfairSync(permits);
}
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);
}
// ... 内部类 FairSync 和 NonfairSync 的实现
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 (next < current) // overflow
throw new Error("Maximum permit count exceeded");
if (compareAndSetState(current, next))
return true;
}
}
}
static final class FairSync extends Sync {
FairSync(int permits) {
super(permits);
}
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;
}
}
}
static final class NonfairSync extends Sync {
NonfairSync(int permits) {
super(permits);
}
protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}
}
}
从源码中，我们可以看到：
Semaphore使用了内部类Sync，FairSync和NonfairSync分别实现了公平模式和非公平模式。Sync继承自AbstractQueuedSynchronizer（AQS），AQS 是 Java 并发包中一个非常重要的组件，用于构建锁和其他同步器。它提供了一个基于 FIFO 等待队列的框架。FairSync的tryAcquireShared方法会检查等待队列中是否有线程。如果有，则阻塞当前线程，保证公平性。NonfairSync的tryAcquireShared方法会直接尝试获取许可，减少了锁竞争。acquire()和release()方法都使用了 AQS 的方法来实现线程的阻塞和唤醒。
6. 注意事项和最佳实践
在使用 Semaphore 时，需要注意以下几点：
- 避免死锁：在使用多个
Semaphore时，需要小心避免死锁。例如，线程 A 拥有SemaphoreX，需要获取SemaphoreY，同时线程 B 拥有SemaphoreY，需要获取SemaphoreX。这可能导致死锁。 - 正确释放许可：确保在完成对共享资源的访问后，正确地释放许可。否则，可能导致资源耗尽，甚至出现死锁。
- 合理设置许可数量：根据实际情况，合理设置
Semaphore的初始许可数量。如果许可数量设置过小，可能导致线程长时间等待。如果许可数量设置过大，可能导致资源浪费。 - 考虑性能：在选择公平模式还是非公平模式时，需要考虑性能和公平性之间的权衡。在高并发场景下，非公平模式通常是更好的选择。
- 结合其他并发工具：
Semaphore可以与其他并发工具结合使用，例如Lock、Condition等，以实现更复杂的同步逻辑。
7. 总结
Semaphore 是一个非常有用的并发工具，可以帮助我们控制对共享资源的并发访问。在使用 Semaphore 时，我们需要根据具体的应用场景，选择合适的模式。公平模式可以保证线程的公平性，但可能影响性能。非公平模式可以提高吞吐量，但可能导致“饥饿”现象。希望通过这篇文章，你能够更深入地理解 Semaphore 的工作原理和使用方法。在实际开发中，我们需要根据实际情况进行权衡和选择，以实现最佳的性能和可靠性。
希望这篇文章对你有所帮助！如果你有任何问题，欢迎随时提问。祝你编程愉快！
