本教程探讨了在java多线程环境中，如何利用`semaphore`实现线程间的交替执行同步，以达到特定序列输出（如“121212”）。文章分析了初学者常犯的错误——为每个线程创建独立的同步器实例，导致线程间无法通信。核心解决方案在于确保所有相关线程共享同一个`semaphore`实例，从而正确协调它们的执行顺序。通过示例代码，详细演示了如何正确配置和使用`semaphore`来构建高效且无竞争的多线程协作机制。
在并发编程中，线程间的协作与同步是构建健壮系统的关键。当多个线程需要按照特定顺序或互斥地访问资源时，同步机制显得尤为重要。本教程将以一个典型的场景为例：两个线程（或两个不同的操作）需要交替执行，一个打印“1”，另一个打印“2”，最终输出“121212...”。我们将重点介绍如何使用Java的Semaphore（信号量）来实现这一目标，并分析常见的陷阱及正确的实践方法。
理解问题：实现线程交替执行
我们的目标是让两个线程T1和T2协同工作。T1负责打印数字“1”，T2负责打印数字“2”。要求是：
- T1先打印“1”。
- T1完成后，T2才能打印“2”。
- T2完成后，T1才能再次打印“1”。
- 以此类推，实现“121212...”的输出序列。
这种场景非常适合使用信号量来协调。信号量可以控制对共享资源的访问，通过许可（permit）的数量来限制同时访问的线程数。
初始尝试与常见陷阱分析
许多初学者在尝试解决此类问题时，可能会遇到程序无法按预期执行，甚至出现死锁的情况。一个常见的错误模式是为每个线程创建独立的同步器实例。
立即学习“Java免费学习笔记（深入）”；
考虑以下一个有问题的代码示例：
import java.util.concurrent.Semaphore;
public class SemTestProblem {
Semaphore sem1 = new Semaphore(1); // 为线程1准备的信号量
Semaphore sem2 = new Semaphore(0); // 为线程2准备的信号量
public static void main(String args[]) {
// 错误：创建了两个SemTestProblem实例
final SemTestProblem instance1 = new SemTestProblem();
final SemTestProblem instance2 = new SemTestProblem();
new Thread(() -> {
try {
instance1.numb1(); // 线程1操作instance1的信号量
} catch (Exception e) {
throw new RuntimeException(e);
}
}).start();
new Thread(() -> {
try {
instance2.numb2(); // 线程2操作instance2的信号量
} 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(100); // 模拟工作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
private void numb2() {
while (true) {
try {
sem2.acquire(); // 获取sem2许可
System.out.print(" 2");
sem1.release(); // 释放sem1许可
Thread.sleep(100); // 模拟工作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
}运行上述代码，你会发现程序可能只打印了一个“1”就停止了，或者行为异常。问题出在main方法中： final SemTestProblem instance1 = new SemTestProblem();final SemTestProblem instance2 = new SemTestProblem();
这里创建了SemTestProblem的两个独立实例。每个实例都拥有自己独立的sem1和sem2信号量。Thread-1调用instance1.numb1()，操作的是instance1内部的sem1和sem2。而Thread-2调用instance2.numb2()，操作的是instance2内部的sem1和sem2。
这意味着两个线程之间并没有共享任何信号量实例。它们各自在自己的“沙盒”中运行，彼此无法通过信号量进行通信和协调。Thread-1释放的instance1.sem2许可，对Thread-2尝试获取的instance2.sem2许可没有任何影响。这就是导致同步失败的根本原因。
正确的解决方案：共享信号量实例
要解决上述问题，核心思想是确保所有参与同步的线程都操作同一个信号量实例。这可以通过几种方式实现：
- 使用静态（static）信号量： 将信号量声明为类的静态成员，所有实例和线程都将共享这些静态成员。
- 传递信号量实例： 在创建线程或Runnable时，将共享的信号量实例作为参数传递进去。
- 单例模式： 确保只有一个包含信号量的SemTest实例被创建，并由所有线程共享。
在这里，我们采用将信号量声明为静态成员的方式，这通常是最简洁明了的解决方案之一。
import java.util.concurrent.Semaphore;
public class SemTestCorrect {
// 将信号量声明为静态成员，确保所有线程共享同一组信号量
private static Semaphore sem1 = new Semaphore(1); // 初始许可1，允许Thread-1先执行
private static Semaphore sem2 = new Semaphore(0); // 初始许可0，Thread-2需等待Thread-1释放
public static void main(String args[]) {
// 只需一个SemTestCorrect实例（如果方法不是静态的）
// 或者直接在main方法中创建并启动线程，让他们访问静态信号量
// 创建并启动线程1
new Thread(() -> {
try {
// 直接调用静态方法或通过任意实例调用，都会访问静态信号量
numb1();
} catch (Exception e) {
throw new RuntimeException(e);
}
}).start();
// 创建并启动线程2
new Thread(() -> {
try {
// 直接调用静态方法或通过任意实例调用，都会访问静态信号量
numb2();
} catch (Exception e) {
throw new RuntimeException(e);
}
}).start();
}
// 将方法也改为静态，以便直接在静态上下文中调用
private static void numb1() {
while (true) {
try {
sem1.acquire(); // 获取sem1许可，如果无许可则阻塞
System.out.print(" 1");
sem2.release(); // 释放sem2许可，唤醒等待sem2的线程
Thread.sleep(100); // 模拟工作，可观察到交替效果
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.err.println("Thread 1 interrupted.");
break; // 退出循环
}
}
}
private static void numb2() {
while (true) {
try {
sem2.acquire(); // 获取sem2许可，如果无许可则阻塞
System.out.print(" 2");
sem1.release(); // 释放sem1许可，唤醒等待sem1的线程
Thread.sleep(100); // 模拟工作
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 重新设置中断状态
System.err.println("Thread 2 interrupted.");
break; // 退出循环
}
}
}
}代码解析：
-
静态信号量声明： private static Semaphore sem1 = new Semaphore(1); 和 private static Semaphore sem2 = new Semaphore(0);
- sem1初始化许可为1，这意味着numb1方法（或负责打印“1”的线程）可以在程序启动时立即获取许可并执行。
- sem2初始化许可为0，这意味着numb2方法（或负责打印“2”的线程）在程序启动时将无法获取许可，必须等待。
- static关键字确保了sem1和sem2是类级别的，所有SemTestCorrect的实例（即使我们只创建了一个或没有创建实例，直接通过类名访问）都共享这两个信号量。
-
numb1()方法逻辑：
- sem1.acquire();：尝试获取sem1的许可。如果当前有许可（例如初始时），则获取成功并继续执行。如果没有，则线程阻塞，直到有其他线程释放sem1的许可。
- System.out.print(" 1");：打印数字“1”。
- sem2.release();：释放sem2的一个许可。这会使得等待sem2许可的线程有机会获取许可并继续执行。
-
numb2()方法逻辑：
- sem2.acquire();：尝试获取sem2的许可。由于sem2初始为0，numb2线程会在此处阻塞，直到numb1线程执行sem2.release()。
- System.out.print(" 2");：打印数字“2”。
- sem1.release();：释放sem1的一个许可。这会使得等待sem1许可的线程有机会获取许可并继续执行。
通过这种“一放一取”的机制，两个线程得以严格按照“121212...”的顺序交替执行。
替代方案：使用synchronized或ReentrantLock
虽然Semaphore非常适合这种交替执行的场景，但Java中还有其他同步机制可以实现类似功能，例如：
- synchronized关键字： 可以用于方法或代码块，实现互斥访问。结合wait()和notify()（或notifyAll()）方法，可以实现线程间的协调和通信。
- ReentrantLock与Condition： ReentrantLock提供了比synchronized更灵活的锁定机制，而其伴随的Condition接口则提供了更精细的线程等待/通知控制。对于复杂的等待条件，Condition比wait/notify更强大。
对于本例中的简单交替打印，Semaphore的实现简洁而直观。
注意事项与总结
- 共享性是关键： 无论使用何种同步原语（Semaphore、Lock、synchronized），确保所有参与同步的线程都操作同一个实例是至关重要的。否则，同步机制将失效。
- 初始许可数量： Semaphore的初始许可数量决定了哪个线程可以先开始执行，以及有多少个线程可以同时访问。在本例中，sem1为1，sem2为0，精确控制了启动顺序。
- 死锁风险： 不当的acquire()和release()顺序或不匹配的操作可能导致死锁。例如，如果一个线程acquire()了许可却未能release()，其他等待该许可的线程将永远阻塞。
- 中断处理： acquire()方法会抛出InterruptedException，在实际应用中应妥善处理，通常是捕获异常并重新设置线程的中断状态，或者根据业务逻辑决定是继续还是退出。
- 公平性： Semaphore可以创建为公平（new Semaphore(permits, true)）或非公平（默认）模式。公平信号量会按请求顺序授予许可，非公平信号量则可能允许“插队”，非公平通常吞吐量更高，但可能导致饥饿。
通过本教程，我们深入理解了如何利用Java Semaphore实现多线程间的交替执行同步，并强调了共享同步器实例的重要性。掌握这些概念对于编写高效、正确且无竞争的并发程序至关重要。
