Java Semaphore案例

wen java案例 2026-08-03 219

Java Semaphore实战指南：从信号量原理到高并发限流案例解析

目录导读

信号量（Semaphore）核心概念：为什么它是JUC的“限流之王”？
源码级原理剖析：AQS如何支撑Semaphore的公平/非公平策略？
业务场景全景图：数据库连接池、接口限流、生产者消费者模型
Java Semaphore实战案例（附详细代码与注释）
- 案例1：模拟数据库连接池获取/释放
- 案例2：双票口抢票系统的流量控制
高频面试问答：如何回答“Semaphore与CountDownLatch区别”？
性能调优避坑指南：避免死锁、信号量泄漏的5个黄金法则

正文精讲

信号量（Semaphore）核心概念

Semaphore（信号量）是Java并发包（java.util.concurrent）中用于控制同时访问特定资源的线程数量的同步工具，它内部维护一个许可（Permit）计数器，线程执行前必须通过acquire()获取许可，若许可耗尽则阻塞；执行完毕后通过release()归还许可。

Java Semaphore案例

关键特性：

非重入性：与Lock不同，Semaphore不跟踪持有者，任何线程都可释放许可（需自行防止误释放）。
二进制信号量：许可数为1时，可当作互斥锁（Mutex）使用。

源码级原理剖析

Semaphore底层基于AbstractQueuedSynchronizer（AQS）实现，通过内部类Sync（继承AQS）管理状态值state（即剩余许可数）。

公平模式（FairSync）：hasQueuedPredecessors()判断是否有等待线程，确保先到先得，避免线程饥饿，但吞吐量略低。
非公平模式（NonfairSync）：直接尝试CAS减少许可，可能“插队”，适合高并发场景，吞吐量更高。

关键源码片段（非公平获取许可）：

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

业务场景全景图

数据库连接池：限制同时获取连接的线程数（如10个连接，100个线程并发）。
API网关限流：每秒最多处理1000个请求，超出的请求快速失败或排队。
生产者-消费者：控制缓冲区为空时消费者的阻塞，以及缓冲区满时生产者的阻塞。
多任务分批处理：如定时任务中，限制同时下载文件的数量。

Java Semaphore实战案例

案例1：模拟数据库连接池

public class DBPool {
    private final Semaphore semaphore;
    private final List<Connection> connections = new ArrayList<>();
    public DBPool(int poolSize) {
        semaphore = new Semaphore(poolSize, true);
        // 初始化连接，此处省略具体Connection创建
        for (int i = 0; i < poolSize; i++) connections.add(createConnection());
    }
    public Connection getConnection() throws InterruptedException {
        semaphore.acquire(); // 获取许可，若池空则阻塞
        return getNextAvailableConnection();
    }
    public void releaseConnection(Connection conn) {
        connections.add(conn);
        semaphore.release(); // 释放许可，唤醒等待线程
    }
}

运行解析：6个线程同时请求连接，池大小仅3个，但有4个线程会阻塞直到有连接归还。

案例2：双票口抢票系统限流（无锁化设计）

public class TicketSystem {
    private static final Semaphore semaphore = new Semaphore(2); // 允许2个窗口同时售票
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + " 正在售票，剩余可用窗口数：" + semaphore.availablePermits());
                    // 模拟售票耗时
                    Thread.sleep(2000);
                } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
                finally {
                    semaphore.release();
                }
            }, "顾客-" + i).start();
        }
    }
}

效果：任意时刻最多2个线程执行售票操作，其余8个线程排队等待，实现精确流量控制。

高频面试问答

Q1：Semaphore与CountDownLatch的区别？

Semaphore控制并发数量（多个线程同时执行），CountDownLatch控制等待条件（一个或多个线程等待其他线程完成）。
Semaphore可循环使用（释放后许可恢复），CountDownLatch只能使用一次（计数归零后失效）。

Q2：Semaphore会死锁吗？如何避免？
可能死锁：如线程A持有许可等待线程B释放许可，而线程B又在等A释放。
规避：

acquire()超时版本tryAcquire(timeout, TimeUnit.SECONDS)。
统一释放时机（finally块中释放）。
避免在持有许可时调用其他可能阻塞的获取方法。

性能调优避坑指南

问题	解决方案
许可泄漏	使用`finally { semaphore.release(); }`强制释放
公平性选择	高并发可容忍饥饿时选非公平；要求任务顺序时选公平（性能下降约10%-15%）
动态调整许可数	通过`drainPermits()`清空许可，或`increasePermits()`（需自定义）
与Synchronized区别	Semaphore可中断响应、支持超时、可灵活控制多个资源；Synchronized只能锁对象