Java并发编程：使用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();
            }
        }
    }
}

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; // 退出循环
            }
        }
    }
}