Java多线程同步：使用Semaphore实现交替执行与共享资源管理

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();
            }
        }
    }
}

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