当前位置：首页 > 文章列表 > 文章 > java教程 > Java线程信号量同步机制解析

Java线程信号量同步机制解析

2025-10-31 09:31:31 0浏览收藏

一分耕耘，一分收获！既然都打开这篇《Java线程信号量同步方法详解》，就坚持看下去，学下去吧！本文主要会给大家讲到等等知识点，如果大家对本文有好的建议或者看到有不足之处，非常欢迎大家积极提出！在后续文章我会继续更新文章相关的内容，希望对大家都有所帮助！

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