Semaphore线程交替方法与常见问题解析

本文深入剖析了如何用 Semaphore 实现两个线程严格交替执行（如输出“FooBarFooBar…”），直击初学者常见误区——误将串行调用当作多线程协作，导致信号量机制完全失效；通过清晰的原理讲解、可直接运行的修复代码及关键注意事项（如信号量初始值设计、异常处理规范、正确线程启动方式），揭示了 Semaphore 在线程协调中既简洁又易错的本质，帮你避开陷阱、真正掌握并发控制的核心逻辑。

本文详解如何使用 Semaphore 实现两个线程严格交替执行（如输出 "FooBarFooBar..."），指出原代码因串行调用导致的逻辑失效问题，并提供可运行的多线程解决方案及关键注意事项。

本文详解如何使用 Semaphore 实现两个线程严格交替执行（如输出 "FooBarFooBar..."），指出原代码因串行调用导致的逻辑失效问题，并提供可运行的多线程解决方案及关键注意事项。

在 Java 并发编程中，Semaphore 是一种经典的同步工具，常用于控制对共享资源的访问或协调线程执行顺序。但初学者常误以为仅靠 acquire()/release() 的配对逻辑就能天然支持线程协作——实际上，线程调度时机与启动方式才是决定协作能否生效的关键。

原代码的核心问题并非 Semaphore 逻辑错误，而在于 main 方法中以串行方式依次调用 foo() 和 bar()：

pt.foo(printFo); // 主线程阻塞执行完全部5次Foo
pt.bar(printBa); // 主线程再阻塞执行全部5次Bar

这导致整个流程完全在单线程（主线程）中完成，两个 Semaphore 的信号量流转形同虚设，根本未触发多线程竞争与等待机制，自然无法实现交替输出。

✅ 正确做法是：将 foo() 和 bar() 分别交由两个独立线程并发执行，并确保它们共享同一 printThread 实例。以下是优化后的完整可运行示例：

import java.util.concurrent.Semaphore;

public class PrintThread {
    private final int n = 5;
    private final Semaphore fooPermit = new Semaphore(1); // 初始允许foo先执行
    private final Semaphore barPermit = new Semaphore(0);  // bar初始不可执行

    public void foo(Runnable printFoo) {
        for (int i = 0; i < n; i++) {
            try {
                fooPermit.acquire(); // 等待获取foo执行权
                printFoo.run();       // 输出"Foo"
                barPermit.release();  // 释放bar执行权
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Foo thread interrupted", e);
            }
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        for (int i = 0; i < n; i++) {
            barPermit.acquire(); // 等待bar执行权
            printBar.run();      // 输出"Bar"
            fooPermit.release(); // 释放foo执行权
        }
    }

    public static void main(String[] args) throws Exception {
        PrintThread pt = new PrintThread();
        Runnable printFoo = () -> System.out.print("Foo");
        Runnable printBar = () -> System.out.print("Bar");

        Thread t1 = new Thread(() -> pt.foo(printFoo));
        Thread t2 = new Thread(() -> {
            try {
                pt.bar(printBar);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        t1.start();
        t2.start();

        // 等待两线程完成（更健壮的做法是使用CountDownLatch）
        t1.join();
        t2.join();

        System.out.println(); // 换行，便于观察输出
    }
}

? 关键要点说明：

• 信号量初始值设计：fooPermit = new Semaphore(1) 确保 foo 线程首次能立即执行；barPermit = new Semaphore(0) 保证 bar 必须等待 foo 首次 release() 后才能开始。
• 异常处理规范化：foo() 中捕获 InterruptedException 并恢复中断状态（interrupt()），避免吞没中断信号；bar() 声明抛出异常，符合 Semaphore.acquire() 的契约。
• 线程启动与同步：使用 Thread.start() 并发启动，配合 join() 确保主线程等待子线程结束，避免程序提前退出导致输出不全。
• 避免 Thread.sleep(1000)：硬编码休眠不可靠（可能过早或过晚），应优先采用 join() 或 CountDownLatch 等显式同步机制。

⚠️ 常见误区提醒：

• 不要在线程方法中直接调用 System.out.print() —— 应通过 Runnable 参数解耦，提升可测试性与复用性；
• Semaphore 不是锁替代品：它不绑定持有线程，acquire()/release() 可跨线程调用，但需严格配对，否则将引发信号量泄漏或死锁；
• 若需更高可靠性（如超时控制、取消支持），可考虑 ReentrantLock 配合 Condition，但本场景 Semaphore 更简洁直观。

运行上述代码，稳定输出：

FooBarFooBarFooBarFooBarFooBar

精准达成「交替执行」目标——这正是 Semaphore 在线程协作场景中的典型价值体现。

以上就是《Semaphore线程交替方法与常见问题解析》的详细内容，更多关于的资料请关注golang学习网公众号！