三线程交替打印ABC

ABCABCABC...ABCABC

class ThreeThreadPrinter1 {
    // 创建一个对象作为锁对象
    private val lock = Object()
    private var num = 0
    fun printA() {
        for (i in 0..100) {
            synchronized(lock) {
                while (num % 3 != 0) {
                    lock.wait()
                }
                println("A")
                num++
                lock.notifyAll()
            }
        }
    }

    // 打印B的方法
    fun printB() {
        for (i in 0..100) {
            synchronized(lock) {
                while (num % 3 != 1) {
                    lock.wait()
                }
                println("B")
                num++
                lock.notifyAll()
            }
        }
    }

    // 打印C的方法
    fun printC() {
        for (i in 0..100) {
            synchronized(lock) {
                while (num % 3 != 2) {
                    lock.wait()
                }
                println("C")
                num++
                lock.notifyAll()
            }
        }
    }

    companion object {
        @JvmStatic
        fun main(args: Array<String>) {
            val printer = ThreeThreadPrinter1()
            // 创建三个线程，分别调用printA, printB, printC方法
            val threadA = Thread { printer.printA() }
            val threadB = Thread { printer.printB() }
            val threadC = Thread { printer.printC() }
            // 启动三个线程
            threadA.start()
            threadB.start()
            threadC.start()
            // 等待3个线程执行完了之后，再退出main线程
            threadA.join()
            threadB.join()
            threadC.join()
        }
    }
}

// 创建一个可重入锁
private final ReentrantLock lock = new ReentrantLock();
// 创建一个Condition对象，用于线程间的协调
private final Condition condition = lock.newCondition();
// 用于跟踪当前应该打印哪个字符的状态变量
private int state = 0;

// 打印A的方法
public void printA() {
    for (int i = 0; i < 10; i++) {
        lock.lock(); // 获取锁
        try {
            // 如果当前状态不是0，则等待
            while (state % 3 != 0) {
                condition.await();
            }
            System.out.println("A");
            state++;
            // 唤醒所有等待的线程
            condition.signalAll();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}

Semaphore(1)：表示信号量初始时有1个许可。通常用于实现类似互斥锁的功能，即一次只允许一个线程访问某个资源。
Semaphore(0)：表示信号量初始时没有许可。任何调用 acquire() 的线程都会被阻塞，直到有其他线程调用 release() 增加许可。
Semaphore(n)：表示信号量初始时有 n 个许可。最多允许 n 个线程同时访问某个资源。