本教程探讨了在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许可没有任何影响。这就是导致同步失败的根本原因。
TextCortex
AI写作能手，在几秒钟内创建内容。
62 查看详情 
正确的解决方案：共享信号量实例
要解决上述问题，核心思想是确保所有参与同步的线程都操作同一个信号量实例。这可以通过几种方式实现：
使用静态（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实现多线程间的交替执行同步，并强调了共享同步器实例的重要性。掌握这些概念对于编写高效、正确且无竞争的并发程序至关重要。
以上就是Java多线程同步：使用Semaphore实现交替执行与共享资源管理的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/982636.html
微信扫一扫 
支付宝扫一扫 
