本文详解如何使用 Java Semaphore 实现两个线程严格交替执行（如输出 "FooBarFooBar..."），指出原代码因串行调用导致失效的根本原因，并提供可运行、线程安全的完整解决方案。
本文详解如何使用 java `semaphore` 实现两个线程严格交替执行（如输出 "foobarfoobar..."），指出原代码因串行调用导致失效的根本原因，并提供可运行、线程安全的完整解决方案。
在多线程协作场景中，常需控制多个线程按特定顺序交替执行——例如实现 FooBar 交替打印。Semaphore（信号量）是实现此类同步逻辑的理想工具：它通过许可（permit）的获取与释放，精确协调线程执行节奏。但若使用不当（如在主线程中串行调用两个方法），将完全丧失并发性，导致预期失效。
? 核心问题：原代码为何不工作？
原始代码中，main 方法内依次调用：
pt.foo(printFo); // 阻塞式执行完全部5次Foo pt.bar(printBa); // 再执行全部5次Bar
这本质上是单线程串行执行，两个 Runnable 并未并发运行，Semaphore 的 acquire()/release() 完全失去意义，自然无法实现交替。
真正有效的方案必须满足：
- ✅ foo() 和 bar() 在独立线程中并发启动；
- ✅ Semaphore 初始状态合理：foo 先行 → f = new Semaphore(1)（允许首次执行），t = new Semaphore(0)（阻塞 bar 直到 foo 首次释放）；
- ✅ 每次执行后立即释放对方许可，形成“你放我、我放你”的闭环。
✅ 正确实现：双线程 + 协作信号量
以下是精简、健壮、符合最佳实践的完整代码：
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(); // 等待轮到自己
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(); // 等待 foo 释放许可
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(); // 换行，便于观察输出
}
}预期输出：
FooBarFooBarFooBarFooBarFooBar
⚠️ 关键注意事项
- 勿忽略中断处理：acquire() 可能被中断，务必捕获 InterruptedException 并恢复中断状态（Thread.currentThread().interrupt()），避免掩盖线程取消意图。
- 避免 Thread.sleep() 硬等待：原答案中 Thread.sleep(1000) 不可靠（可能过早结束或过度延迟）。应使用 join() 或 CountDownLatch 精确同步主线程与工作线程。
- 语义清晰命名：将 f/t 改为 fooPermit/barPermit，大幅提升可读性与可维护性。
- final 修饰符增强安全性：n、Semaphore 实例声明为 final，明确其不可变性，符合并发编程习惯。
✅ 总结
Semaphore 实现线程交替的本质是状态驱动的许可传递：一个线程执行后释放另一个线程所需的许可，形成确定性的执行链。成功的关键在于：
- 并发执行（启用独立线程），
- 初始许可配置正确（谁先谁后需匹配 acquire/release 顺序），
- 每次操作原子闭环（acquire → work → release 缺一不可）。
掌握此模式，即可灵活扩展至 FooBarBaz 三线程循环、生产者-消费者配对等更复杂协同场景。
