本文深入探讨了在Java中使用Semaphore实现两个线程交替、顺序执行特定任务的机制。通过分析一个常见的编程错误——即线程未能共享同一个Semaphore实例，导致同步失效——我们展示了如何正确地初始化和共享Semaphore，以确保线程之间能够有效协调，从而实现“121212...”这样的精确输出序列。
在多线程编程中，确保线程以特定顺序执行任务是常见的需求。Java提供了多种同步机制来协调线程间的操作，其中Semaphore（信号量）是一种强大的工具，它允许我们控制对共享资源的并发访问数量。本文将详细介绍如何利用Semaphore实现两个线程的严格交替执行，并纠正一个在实践中容易犯的错误。
线程交替执行的需求与Semaphore原理
设想一个场景：我们需要两个线程，一个打印数字“1”（我们称之为P1），另一个打印数字“2”（P2）。要求它们的输出严格按照“121212...”的顺序交替进行。这意味着P1必须先打印“1”，然后P2才能打印“2”，P2完成后P1才能再次打印“1”，如此循环。
Semaphore通过维护一个许可计数器来工作。acquire()方法会尝试获取一个许可，如果计数器为零，线程将被阻塞直到有许可可用。release()方法会释放一个许可，增加计数器。通过巧妙地初始化和操作Semaphore的许可，我们可以实现线程间的顺序控制。
立即学习“Java免费学习笔记（深入）”；
为了实现“1212”的交替打印，我们可以使用两个Semaphore：
- sem1：初始许可为1，用于控制P1线程的执行。
- sem2：初始许可为0，用于控制P2线程的执行。
具体流程如下：
- P1线程尝试获取sem1的许可。由于sem1初始许可为1，P1可以立即获取并执行。
- P1打印“1”后，释放sem2的许可。
- P2线程尝试获取sem2的许可。由于P1刚刚释放了sem2的许可，P2可以立即获取并执行。
- P2打印“2”后，释放sem1的许可。
- 循环往复，P1再次获取sem1的许可，形成交替执行。
常见错误：Semaphore实例未共享
在实现上述逻辑时，一个非常常见的错误是，不同的线程实例操作的是各自独立的Semaphore实例，导致它们之间无法进行有效的同步。考虑以下错误示例代码：
import java.util.concurrent.Semaphore;
public class SemTestIncorrect {
// 每个SemTestIncorrect实例都会有自己的sem1和sem2
Semaphore sem1 = new Semaphore(1);
Semaphore sem2 = new Semaphore(0);
public static void main(String args[]) {
// 错误：创建了两个SemTestIncorrect实例
// 每个实例都有自己独立的sem1和sem2
final SemTestIncorrect semTest1 = new SemTestIncorrect();
final SemTestIncorrect semTest2 = new SemTestIncorrect();
new Thread() {
@Override
public void run() {
try {
semTest1.numb1(); // 线程1操作semTest1的semaphores
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}.start();
new Thread() {
@Override
public void run() {
try {
semTest2.numb2(); // 线程2操作semTest2的semaphores
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}.start();
}
private void numb1() {
while (true) {
try {
sem1.acquire(); // 获取当前实例的sem1
System.out.print(" 1");
sem2.release(); // 释放当前实例的sem2
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void numb2() {
while (true) {
try {
sem2.acquire(); // 获取当前实例的sem2
System.out.print(" 2");
sem1.release(); // 释放当前实例的sem1
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}上述代码的问题在于 main 方法中创建了两个 SemTestIncorrect 对象：semTest1 和 semTest2。每个对象都拥有自己独立的 sem1 和 sem2 信号量实例。第一个线程调用 semTest1.numb1()，操作的是 semTest1 内部的 sem1 和 sem2。而第二个线程调用 semTest2.numb2()，操作的是 semTest2 内部的 sem1 和 sem2。由于这两个线程操作的是不同的信号量对，它们之间无法进行任何通信和同步，导致程序在打印一个“1”之后就停止（因为 semTest1 释放了它自己的 sem2，但 semTest2 的 sem2 仍然为0，无法被获取）。
正确的解决方案：共享Semaphore实例
要解决这个问题，关键在于确保所有参与同步的线程都操作同一个Semaphore实例。这可以通过多种方式实现，例如：
- 将Semaphore声明为static成员，使其成为类级别的共享资源。
- 在main方法中创建Semaphore实例，并通过构造函数或方法参数传递给线程或其执行的Runnable/Callable。
- 只创建一个包含Semaphore的类实例，并让所有线程都调用该实例的方法。
以下是采用第三种方式的修正代码，这也是最直接且符合面向对象原则的修正：
import java.util.concurrent.Semaphore;
public class SemTestCorrect {
// Semaphores现在属于这个类的实例
private final Semaphore sem1 = new Semaphore(1); // P1先执行
private final Semaphore sem2 = new Semaphore(0); // P2后执行
public static void main(String args[]) {
// 正确：只创建一个SemTestCorrect实例
// 两个线程将操作这同一个实例中的sem1和sem2
final SemTestCorrect sharedSemTest = new SemTestCorrect();
new Thread(() -> { // 使用Lambda表达式简化线程创建
try {
sharedSemTest.numb1(); // 线程1操作共享实例的semaphores
} catch (Exception e) {
throw new RuntimeException(e);
}
}).start();
new Thread(() -> { // 使用Lambda表达式简化线程创建
try {
sharedSemTest.numb2(); // 线程2操作共享实例的semaphores
} catch (Exception e) {
throw new RuntimeException(e);
}
}).start();
}
public void numb1() {
while (true) {
try {
sem1.acquire(); // P1获取sem1许可
System.out.print(" 1");
sem2.release(); // P1释放sem2许可，允许P2执行
Thread.sleep(500); // 模拟工作耗时
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.out.println("P1 interrupted.");
break; // 退出循环
}
}
}
public void numb2() {
while (true) {
try {
sem2.acquire(); // P2获取sem2许可
System.out.print(" 2");
sem1.release(); // P2释放sem1许可，允许P1执行
Thread.sleep(500); // 模拟工作耗时
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.out.println("P2 interrupted.");
break; // 退出循环
}
}
}
}在这段修正后的代码中，main方法只创建了一个 SemTestCorrect 实例 sharedSemTest。两个线程都通过这个同一个 sharedSemTest 实例来调用 numb1() 和 numb2() 方法。这样，它们就能够访问并操作同一个 sem1 和 sem2 信号量对象，从而实现正确的交替执行。输出将是连续的“1 2 1 2 1 2...”。
注意事项与总结
- 共享资源原则： 任何用于线程间同步的机制（如Semaphore, Lock, Condition, volatile变量等）都必须是所有相关线程能够访问到的同一个实例。这是多线程编程中最基本也是最重要的原则之一。
- InterruptedException处理： 当线程在等待获取许可时被中断，acquire()方法会抛出InterruptedException。正确的处理方式是捕获异常，并通常重新设置线程的中断状态 (Thread.currentThread().interrupt();)，然后决定是继续执行还是退出循环。
- Semaphore与Mutex： 当Semaphore的许可数量设置为1时，它实际上充当了一个二元信号量，功能类似于互斥锁（Mutex）。Java中的ReentrantLock是更常用的互斥锁实现，它提供了更丰富的锁定功能，例如条件变量（Condition）。对于这种严格的交替执行模式，使用两个Semaphore进行信号传递是一种简洁有效的方法。如果使用ReentrantLock，通常需要配合Condition对象来完成类似的等待/通知机制。
- 死锁风险： 在复杂的同步场景中，不当的Semaphore使用可能导致死锁。例如，如果线程A持有Semaphore X并尝试获取Semaphore Y，而线程B持有Semaphore Y并尝试获取Semaphore X，就可能发生死锁。本例中的设计避免了这种风险，因为每个线程只尝试获取一个特定的Semaphore，并在完成后释放另一个。
通过本文的讲解和修正后的代码示例，我们理解了如何正确利用Java的Semaphore实现线程间的精确交替执行，并强调了共享同步资源的重要性。掌握这些基本概念对于编写健壮、高效的并发程序至关重要。
