当前位置：首页 > 文章列表 > 文章 > java教程 > Java信号量详解与线程同步技巧

Java信号量详解与线程同步技巧

2025-10-26 16:09:36 0浏览收藏

想要提升Java并发编程能力？本文将深入解析Java线程同步利器——Semaphore（信号量）。Semaphore是`java.util.concurrent`包下的关键工具类，它通过维护一组许可(permits)来控制对共享资源的并发访问数量，有效实现线程间的同步与信号传递。文章详细介绍了Semaphore的核心方法`acquire()`和`release()`，并通过代码示例演示了如何利用Semaphore进行限流，防止资源过度消耗，以及如何实现线程间的协作，构建高效的“通知”机制。掌握Semaphore的使用，能有效避免死锁和资源饥饿，提升系统稳定性和性能。无论你是Java并发新手还是经验丰富的开发者，本文都将为你提供Semaphore的全面解读和实战指导。

Semaphore是Java中用于控制并发访问资源的工具类，通过acquire()获取许可和release()释放许可实现线程间同步与信号传递，常用于限流和线程协作。

在Java中如何使用线程间信号量同步

在Java中，线程间的信号量同步主要通过 Semaphore 类来实现。Semaphore 是 java.util.concurrent 包中的一个工具类，用于控制同时访问某一资源的线程数量，也可以用于线程之间的基本信号传递。

什么是 Semaphore

Semaphore 维护了一组许可（permits），线程在访问资源前需要先获取许可，使用完后释放许可。如果没有许可可用，获取许可的线程会被阻塞，直到有其他线程释放许可。

它常用于以下场景：

限制并发访问资源的线程数（如数据库连接池）
实现线程间的简单协作与信号通知

基本用法：acquire() 与 release()

核心方法有两个：

acquire()：尝试获取一个许可，如果没有可用许可，线程会阻塞
release()：释放一个许可，唤醒正在等待的线程

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final Semaphore semaphore = new Semaphore(1); // 只允许一个线程进入

    public static void main(String[] args) {
        Runnable task = () -> {
            try {
                System.out.println(Thread.currentThread().getName() + " 尝试获取信号量");
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 获取到信号量，开始执行");

                // 模拟工作
                Thread.sleep(2000);

                System.out.println(Thread.currentThread().getName() + " 执行完成，释放信号量");
                semaphore.release();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        };

        // 启动多个线程
        for (int i = 0; i

输出结果会显示：虽然三个线程几乎同时启动，但只有一个能立即执行，其余两个会等待第一个线程释放信号量后再依次执行。

使用信号量实现线程协作

Semaphore 也可用于线程间“通知”机制。例如，让一个线程等待另一个线程完成某项准备任务。

import java.util.concurrent.Semaphore;

public class SignalExample {
    private static final Semaphore readySignal = new Semaphore(0); // 初始无许可

    public static void main(String[] args) {
        Thread worker = new Thread(() -> {
            System.out.println("Worker: 等待准备工作完成...");
            try {
                readySignal.acquire(); // 等待信号
                System.out.println("Worker: 收到信号，开始工作");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread preparer = new Thread(() -> {
            System.out.println("Preparer: 开始准备...");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("Preparer: 准备完成，发送信号");
            readySignal.release(); // 发送信号
        });

        worker.start();
        preparer.start();
    }
}

这里，worker 线程调用 acquire() 被阻塞，直到 preparer 线程调用 release() 提供许可，从而实现线程间的“信号通知”。