Java并发：使用Semaphore实现线程交替执行的精确同步

import java.util.concurrent.Semaphore;

public class SemTest {
    Semaphore sem1 = new Semaphore(1); // 实例变量
    Semaphore sem2 = new Semaphore(0); // 实例变量

    public static void main(String args[]) {
        final SemTest semTest1 = new SemTest(); // 第一个实例
        final SemTest semTest2 = new SemTest(); // 第二个实例

        new Thread() {
            @Override
            public void run() {
                try {
                    semTest1.numb1(); // 线程1操作semTest1的实例变量
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }.start();

        new Thread() {
            @Override
            public void run() {
                try {
                    semTest2.numb2(); // 线程2操作semTest2的实例变量
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }.start();
    }

    private void numb1() {
        while (true) {
            try {
                sem1.acquire(); // 获取semTest1的sem1许可
                System.out.print("1");
                sem2.release(); // 释放semTest1的sem2许可
                Thread.sleep(100); // 适当缩短休眠时间，方便观察
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    private void numb2() {
        while (true) {
            try {
                sem2.acquire(); // 获取semTest2的sem2许可
                System.out.print("2");
                sem1.release(); // 释放semTest2的sem1许可
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

import java.util.concurrent.Semaphore;

public class CorrectedSemTest {

    public static void main(String[] args) {
        // 声明并初始化两个共享的Semaphore实例
        // sem1初始许可为1，允许第一个线程立即执行
        final Semaphore sem1 = new Semaphore(1); 
        // sem2初始许可为0，阻止第二个线程在第一个线程完成前执行
        final Semaphore sem2 = new Semaphore(0); 

        // 线程1：负责打印"1"
        new Thread(() -> {
            try {
                while (true) {
                    sem1.acquire(); // 等待获取sem1的许可
                    System.out.print("1"); // 打印"1"
                    sem2.release(); // 释放sem2的许可，允许线程2执行
                    Thread.sleep(100); // 模拟工作
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread 1 interrupted.");
            }
        }, "Thread-1").start(); // 给线程命名方便调试

        // 线程2：负责打印"2"
        new Thread(() -> {
            try {
                while (true) {
                    sem2.acquire(); // 等待获取sem2的许可
                    System.out.print("2"); // 打印"2"
                    sem1.release(); // 释放sem1的许可，允许线程1再次执行
                    Thread.sleep(100); // 模拟工作
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread 2 interrupted.");
            }
        }, "Thread-2").start(); // 给线程命名方便调试
    }
}