JAVA两个线程交替打印实现

方案1 Semaphore 机制

通过信息号机制来 协调两个线程，一个线程打印后，给另一个线程释放一个信号量

  Semaphore semaphorea = new Semaphore(1);
        Semaphore semaphoreb = new Semaphore(0);
        Thread threada = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    try {
                        semaphorea.acquire();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("a");
                    semaphoreb.release();
                }
            }
        });

        Thread threadb = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 50; i++) {
                    try {
                        semaphoreb.acquire();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    System.out.println("b");
                    semaphorea.release();
                }
            }
        });

        threada.start();
        threadb.start();

方案2

通过锁的condition来两个线程协作

public class AlternatePrintAB {

    private static boolean printA = true; // 初始化为true，用于控制打印的起始

    public static void main(String[] args) {
        Lock lock = new ReentrantLock();

        Condition conditiona = lock.newCondition();

        Condition conditionb = lock.newCondition();


        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    try {
                        lock.lock();
                        while (!printA) {
                            try {
                                //不打印A时，A等待
                                conditiona.await();
                                //await 会释放锁，唤醒时，要重新获取锁
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                        System.out.println("A");
                        printA = false;
                        conditionb.signal();
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    } finally {

                        lock.unlock();
                    }
                }

            }
        });


        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    lock.lock();
                    while (printA) {
                        try {
                            //打印A时，B等待
                            conditionb.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("B");
                    printA = true;
                    conditiona.signal();
                }
            }
        });

        thread.start();
        thread1.start();
    }

}