登录
首页 >  文章 >  java教程

Java线程同步：信号量详解与应用

时间：2026-02-16 20:34:35 191浏览 收藏

本文深入解析了Java中Semaphore（信号量）的核心机制与实战应用，揭示其如何通过许可（permits）的获取与释放实现精准的线程同步——既能像“交通管制员”一样限制并发访问资源的线程数量（如数据库连接池限流），又能化身“通信信使”在多线程间可靠传递信号（如等待前置任务完成），辅以清晰代码示例和关键注意事项，帮你避开死锁、资源饥饿等陷阱，真正掌握这一轻量却强大的并发控制利器。

在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() 提供许可，从而实现线程间的“信号通知”。

注意事项

  • 确保每次 acquire() 成功后都有对应的 release()，否则可能导致死锁或资源饥饿
  • 可以使用 tryAcquire() 避免无限等待
  • Semaphore 不是可重入的，同一个线程重复 acquire 可能导致自身阻塞
  • 初始许可数为0时，适合做“等待信号”用途；大于0时，适合做“限流”用途
基本上就这些。Semaphore 使用简单，但在控制并发和线程协作上非常实用。

理论要掌握，实操不能落！以上关于《Java线程同步：信号量详解与应用》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！

资料下载
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>