本文详解如何通过 semaphore 正确实现两个线程交替执行（如打印 "foo" 和 "bar"），指出原代码因串行调用导致同步失效的问题，并提供可运行的多线程解决方案及关键原理说明。
本文详解如何通过 semaphore 正确实现两个线程交替执行（如打印 "foo" 和 "bar"），指出原代码因串行调用导致同步失效的问题，并提供可运行的多线程解决方案及关键原理说明。
在多线程编程中，Semaphore 是一种经典的同步工具，适用于控制对共享资源的访问或协调线程执行顺序。本教程聚焦一个典型场景：让两个线程严格交替执行——即线程 A 打印 "Foo" 后，必须等待线程 B 打印 "Bar"，再轮到 A，如此循环，最终输出形如 FooBarFooBar... 的字符串。
? 原代码为何失效？关键误区解析
原始代码看似逻辑清晰：
- foo() 初始化获取 f=1、等待 t=0；
- bar() 初始化等待 t=0、释放 f；
- 但问题出在 main 方法中 串行调用：
pt.foo(printFo); // 主线程阻塞执行完全部5次Foo pt.bar(printBa); // 等foo返回后才开始执行bar → 完全失去并发与交替意义
此时 Semaphore 未被多线程竞争，acquire()/release() 成为无意义的空转，输出为 FooFooFooFooFooBarBarBarBarBar，严重偏离预期。
✅ 正确做法：必须启动两个独立线程并发执行 foo() 和 bar()，使信号量在真实竞争中发挥调度作用。
✅ 正确实现：双线程 + Semaphore 协作
以下是修复后的完整可运行代码（已优化命名与异常处理）：
import java.util.concurrent.Semaphore;
public class FooBarPrinter {
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(); // 执行打印
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(); // 执行打印
fooPermit.release(); // 允许foo再次执行
}
}
public static void main(String[] args) throws Exception {
FooBarPrinter printer = new FooBarPrinter();
Runnable printFoo = () -> System.out.print("Foo");
Runnable printBar = () -> System.out.print("Bar");
Thread t1 = new Thread(() -> printer.foo(printFoo));
Thread t2 = new Thread(() -> {
try {
printer.bar(printBar);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
});
t1.start();
t2.start();
// 确保主线程等待子线程完成（更健壮的方式是使用 join）
t1.join();
t2.join();
System.out.println(); // 换行便于观察输出
}
}✅ 输出结果：FooBarFooBarFooBarFooBarFooBar
⚠️ 关键注意事项
- join() 替代 sleep()：原答案使用 Thread.sleep(1000) 属于不严谨的“碰运气”等待；应改用 t1.join() 和 t2.join() 显式等待线程结束，确保输出完整性与程序健壮性。
- 中断处理规范：捕获 InterruptedException 后务必恢复中断状态（Thread.currentThread().interrupt()），避免屏蔽中断信号，符合 Java 并发最佳实践。
- Semaphore 初始化语义明确：fooPermit = new Semaphore(1) 表示初始允许 1 次进入；barPermit = new Semaphore(0) 表示 bar 必须等待 foo 首次 release() 后才能执行——这是实现“Foo 优先启动”的核心设计。
- 避免静态方法或共享状态污染：本例中 n、Semaphore 均为实例成员，保障多实例隔离性；若需复用，应确保每个 FooBarPrinter 实例独占其信号量。
? 总结
Semaphore 不是“自动调度器”，而是线程间通信的契约工具：它本身不决定谁先执行，而是依赖开发者精确设计 acquire()/release() 的配对逻辑与初始许可数。要实现严格的交替执行，必须满足三个条件：
- 两个线程并发启动；
- 使用一对互补的信号量（如 S1=1, S2=0）构建“你等我、我等你”的闭环；
- 每次临界操作前后严格配对 acquire() 和 release()。
掌握这一模式，即可灵活扩展至三线程交替（如 FooBarBaz）、生产者-消费者节流等更复杂场景。
