Java基础教程（146）线程同步之使用Semaphore：驾驭并发洪流，深度剖析Java Semaphore，远不止是另一把锁！

最新推荐文章于 2025-11-30 18:24:05 发布

原创最新推荐文章于 2025-11-30 18:24:05 发布 · 264 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

Java基础教程专栏收录该内容

302 篇文章

订阅专栏

在Java并发编程中，当我们谈及“同步”，许多开发者首先想到的是synchronized关键字或ReentrantLock。它们如同单间厕所的钥匙，一次只允许一个线程进入临界区，完美解决了互斥问题。然而，面对更复杂的场景，例如需要限制访问某个资源的最大线程数量时，这些基础锁就显得力不从心了。

这正是Semaphore（信号量）大放异彩的舞台。

一、Semaphore是什么？

Semaphore直译为“信号灯”，它可以控制同时访问特定资源的线程数量。它通过维护一组许可证（permits）来实现这一目标。

核心思想：想象一个停车场，总共有10个车位（许可证）。当有车（线程）要进入时，必须先获取一个空闲车位（acquire()）。如果车位已满，新车就必须等待。当有车离开时，它会释放一个车位（release()），等待的车辆才能进入。
与synchronized的区别：synchronized就像只有一个坑位的厕所，一次绝对只能一个人用。而Semaphore则像是有N个坑位的公共厕所，可以同时容纳N个人，但一旦满员，后来者就必须排队等候。

二、Semaphore的核心API

构造函数：

- Semaphore(int permits)：创建具有给定许可证数量的非公平信号量。
- Semaphore(int permits, boolean fair)：创建具有给定许可证数量和公平性策略的信号量。若fair为true，则保证线程获取许可证的顺序与其请求的顺序一致（FIFO），避免线程饥饿。

关键方法：

- void acquire()：从此信号量获取一个许可证，在提供一个许可证前一直阻塞线程，否则线程被中断。
- void acquire(int permits)：一次性获取指定数量的许可证。
- void release()：释放一个许可证，将其返还给信号量。
- void release(int permits)：释放给定数量的许可证。
- boolean tryAcquire()：尝试获取一个许可证，成功返回true，失败立即返回false，线程不会阻塞。
- boolean tryAcquire(long timeout, TimeUnit unit)：在指定的超时时间内尝试获取许可证。

三、实战示例：停车场调度系统

让我们用代码来生动地演绎上述的停车场比喻。

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreParkingLot {

    // 模拟一个有5个车位的停车场
    private static final int PARKING_SLOTS = 5;
    private static final Semaphore parkingLot = new Semaphore(PARKING_SLOTS, true); // 使用公平锁，先来后到

    public static void main(String[] args) {
        // 模拟10辆汽车试图停车
        for (int carId = 1; carId <= 10; carId++) {
            new Thread(new Car(carId), "Car-" + carId).start();
            // 间隔随机时间开来下一辆车，模拟真实场景
            try {
                Thread.sleep((long) (Math.random() * 500));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class Car implements Runnable {
        private final int id;

        public Car(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            System.out.printf("[%s] 到达停车场，寻找空位...%n",
                    Thread.currentThread().getName(), id);

            try {
                // 尝试在2秒内获取车位
                if (parkingLot.tryAcquire(2, TimeUnit.SECONDS)) {
                    System.out.printf("[%s] ✅ 成功停入车位！(当前剩余车位: %d)%n",
                            Thread.currentThread().getName(),
                            parkingLot.availablePermits());

                    // 模拟车辆在停车场内停留随机时间
                    Thread.sleep((long) (Math.random() * 5000 + 3000)); // 停3-8秒

                    System.out.printf("[%s] 🚗 驶离停车场，释放一个车位。%n",
                            Thread.currentThread().getName());

                } else {
                    // 等待超时，没等到车位
                    System.out.printf("[%s] ❌ 等待超时，没有空位，愤然离去！%n",
                            Thread.currentThread().getName());
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                // 无论如何，最终都要释放许可证（防止因异常导致许可证无法释放）
                parkingLot.release();
            }
        }
    }
}

示例深度解析：

初始化：我们创建了一个拥有5个许可证的公平信号量parkingLot，代表5个车位。
车辆入场（acquire）：每辆Car（线程）尝试使用tryAcquire(2, TimeUnit.SECONDS)在2秒内获取一个许可证。如果成功，它就能“停入”并执行后续逻辑（Thread.sleep模拟停车）。tryAcquire的非阻塞特性避免了线程无限期等待，提升了系统响应性。
车辆离场（release）：车辆停够时间后，在finally块中调用release()方法，确保即使线程中途异常也能释放许可证，这是防止“许可证泄漏”的最佳实践，至关重要！
流量控制：由于只有5个许可证，最多只允许5辆车同时“停在车位上”。第6辆及以后的车辆要么等待前车离开，要么在超时后离去。这完美演示了Semaphore如何有效地控制对有限资源的并发访问量。