本教程深入探讨如何使用Java `Semaphore`实现两个线程的严格交替执行，以产生“121212...”的序列输出。文章首先分析了常见错误——由于`Semaphore`实例未共享导致的同步失效问题，随后提供了正确的解决方案，并通过详细的代码示例展示了如何初始化和使用共享的`Semaphore`对象，以确保线程间的有序协作和精确同步。
一、引言：多线程交替执行的需求
在多线程编程中，我们经常需要协调不同线程的执行顺序，以实现特定的业务逻辑。例如，要求两个线程严格按照“线程A执行一次，然后线程B执行一次，再线程A执行一次……”的模式交替运行。这种场景下，线程间的同步机制至关重要。Java并发包提供了多种同步工具，其中Semaphore（信号量）是实现资源访问控制和线程间协调的强大工具。本教程将重点讲解如何利用Semaphore来解决一个经典的交替打印问题。
我们的目标是实现以下输出序列：12121212....121212，其中“1”由一个线程打印，“2”由另一个线程打印。
二、初始错误尝试与问题分析
为了实现上述目标，一个常见的初步设想是创建两个Semaphore，一个控制线程1的执行，另一个控制线程2的执行，并通过acquire()和release()方法来互相通知。
立即学习“Java免费学习笔记（深入）”；
考虑以下初始代码实现：
import java.util.concurrent.Semaphore;
public class SemTest {
Semaphore sem1 = new Semaphore(1); // 控制线程1，初始允许执行
Semaphore sem2 = new Semaphore(0); // 控制线程2，初始不允许执行
public static void main(String args[]) {
final SemTest semTest1 = new SemTest(); // 实例1
final SemTest semTest2 = new SemTest(); // 实例2
new Thread() {
@Override
public void run() {
try {
semTest1.numb1(); // 线程1操作实例1的numb1方法
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}.start();
new Thread() {
@Override
public void run() {
try {
semTest2.numb2(); // 线程2操作实例2的numb2方法
} 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();
}
}
}
}运行上述代码，你可能会发现程序在打印“1”之后就停止了，无法实现预期的“121212...”序列。
问题分析：
核心问题在于main方法中创建了两个SemTest实例：semTest1和semTest2。
- semTest1拥有自己独立的sem1和sem2信号量。
- semTest2也拥有自己独立的sem1和sem2信号量。
第一个线程调用semTest1.numb1()，它操作的是semTest1内部的sem1和sem2。它成功获取semTest1.sem1的许可，打印“1”，然后释放semTest1.sem2的许可。 第二个线程调用semTest2.numb2()，它操作的是semTest2内部的sem1和sem2。它尝试获取semTest2.sem2的许可，但由于semTest2.sem2的初始许可为0，并且没有任何线程释放过它的许可，所以第二个线程会一直阻塞在那里。
这两个线程之间根本没有通过信号量进行任何交互，因为它们操作的是完全不同的信号量对象。要实现线程间的同步，它们必须共享相同的同步原语。
三、使用Semaphore实现精确交替执行
要解决上述问题，关键在于确保两个线程操作的是同一个Semaphore实例。这意味着sem1和sem2必须是所有参与线程共享的资源。
3.1 核心思想
- 共享信号量实例： 两个线程必须访问同一对sem1和sem2信号量。
- 初始状态： sem1初始化为1个许可，允许第一个线程（打印“1”的线程）先执行。sem2初始化为0个许可，阻止第二个线程（打印“2”的线程）在第一个线程完成前执行。
-
交替机制：
- 打印“1”的线程：获取sem1许可，打印“1”，然后释放sem2许可。
- 打印“2”的线程：获取sem2许可，打印“2”，然后释放sem1许可。 通过这种方式，两个信号量像“令牌”一样在两个线程间传递，确保了严格的交替执行。
3.2 修正后的代码示例
我们将Semaphore实例移到main方法中，并作为局部变量被匿名内部类捕获，从而实现共享。
import java.util.concurrent.Semaphore;
public class CorrectSemTest {
public static void main(String args[]) {
// 关键：sem1和sem2被定义在main方法中，并由匿名线程类“捕获”
// 确保了两个线程操作的是同一对Semaphore实例
final Semaphore sem1 = new Semaphore(1); // 初始允许线程1执行
final Semaphore sem2 = new Semaphore(0); // 初始阻止线程2执行
// 线程1：负责打印“1”
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true) {
sem1.acquire(); // 获取sem1许可，如果为0则阻塞
System.out.print(" 1");
sem2.release(); // 释放sem2许可，允许线程2执行
Thread.sleep(500); // 模拟工作耗时
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 恢复中断状态
System.err.println("Thread 1 interrupted.");
}
}
}).start();
// 线程2：负责打印“2”
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true) {
sem2.acquire(); // 获取sem2许可，如果为0则阻塞
System.out.print(" 2");
sem1.release(); // 释放sem1许可，允许线程1执行
Thread.sleep(500); // 模拟工作耗时
}
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 恢复中断状态
System.err.println("Thread 2 interrupted.");
}
}
}).start();
}
}运行上述CorrectSemTest代码，你将看到预期的“1 2 1 2 1 2 ...”交替输出。
3.3 代码执行流程详解
- 初始化： sem1有1个许可，sem2有0个许可。
-
线程1启动：
- 进入while(true)循环。
- 执行sem1.acquire()。由于sem1有1个许可，线程1成功获取许可，sem1的许可变为0。
- 打印“1”。
- 执行sem2.release()。sem2的许可从0变为1。
- Thread.sleep(500)，线程1暂停。
-
线程2启动：
- 进入while(true)循环。
- 执行sem2.acquire()。此时sem2的许可为1（由线程1释放），线程2成功获取许可，sem2的许可变为0。
- 打印“2”。
- 执行sem1.release()。sem1的许可从0变为1。
- Thread.sleep(500)，线程2暂停。
- 循环往复： 当线程1从睡眠中醒来时，它会再次尝试sem1.acquire()。此时sem1的许可为1（由线程2释放），线程1再次执行。这个过程会无限循环，实现“1”和“2”的交替打印。
四、注意事项与最佳实践
- 共享性是关键： 任何用于线程间同步的工具（Semaphore、Lock、CountDownLatch等）都必须是所有参与线程共享的实例。如果每个线程都有自己的同步工具实例，它们将无法互相协调。
- acquire()与release()的配对： 确保每次acquire()操作都有对应的release()操作，以避免死锁或资源泄露。在我们的例子中，每个线程在完成自己的任务后，都会释放另一个线程所需的许可。
- 异常处理： acquire()方法会抛出InterruptedException，这表示线程在等待许可时被中断。在实际应用中，应妥善处理此异常，通常的做法是捕获异常后重新设置中断标志 (Thread.currentThread().interrupt();)，以便更高层的代码能够感知到中断。
- 选择合适的同步工具： 虽然Semaphore可以解决这类交替执行问题，但在更复杂的条件等待场景下，Object.wait()/notify()或ReentrantLock配合Condition可能提供更灵活的控制。对于简单的资源访问计数或互斥，Semaphore是一个简洁高效的选择。
- 避免在循环中创建线程： 在本教程的例子中，线程是在main方法中一次性创建并启动的。避免在频繁执行的循环中重复创建和销毁线程，这会带来巨大的性能开销。
五、总结
通过本教程，我们学习了如何使用Java Semaphore实现两个线程的精确交替执行。核心要点在于确保所有参与同步的线程共享同一个Semaphore实例。通过巧妙地初始化两个Semaphore（一个初始许可为1，另一个为0），并让线程在完成任务后释放对方所需的许可，我们成功构建了一个稳定的交替执行机制。理解并正确应用这些并发原语是编写高效、健壮多线程应用程序的基础。
