4种方式顺序打印ABC

synchronized

public class Main{
    private static volatile int state;
    public static void main(String[] args) {
        Object o=new Object();
        //打印A
        new Thread(()->{
            //final int num=state;
            for(int i=0;i<10;i++){
                while(state!=0){
                    synchronized(o){
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
                state=(state+1)%3;
                System.out.print("A"+i+"     ");
                synchronized (o){
                    o.notifyAll();
                }
            }
        }).start();
        //打印B
        new Thread(()->{
            //final int num=state;
            for(int i=0;i<10;i++){
                while(state!=1){
                    synchronized(o){
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
                state=(state+1)%3;
                System.out.print("B"+i+"     ");
                synchronized (o){
                    o.notifyAll();
                }
            }
        }).start();
        //打印C
        new Thread(()->{
            //final int num=state;
            for(int i=0;i<10;i++){
                while(state!=2){
                    synchronized(o){
                        try {
                            o.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
                state=(state+1)%3;
                System.out.println("C"+i);
                synchronized (o){
                    o.notifyAll();
                }
            }
        }).start();


    }

}

Lock

public class Main{
    private static volatile int flag;
    public static void main(String[] args) throws InterruptedException {
        Lock lock=new ReentrantLock();
        new Thread(()->{
            for(int i=0;i<10;){
                lock.lock();
                try {
                    if(flag%3==0){
                        System.out.println("A"+i);
                        flag++;
                        i++;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();


        new Thread(()->{
            for(int i=0;i<10;){
                lock.lock();
                try {
                    if(flag%3==1){
                        System.out.println("B"+i);
                        flag++;
                        i++;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();


        new Thread(()->{
            for(int i=0;i<10;){
                lock.lock();
                try {
                    if(flag%3==2){
                        System.out.println("C"+i);
                        flag++;
                        i++;
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

Lock+Condition

public class Main{
    private static volatile int flag;
    public static void main(String[] args) throws InterruptedException {

        Lock lock=new ReentrantLock();
        Condition conditionA=lock.newCondition();
        Condition conditionB=lock.newCondition();
        Condition conditionC=lock.newCondition();
        new Thread(()->{
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    while(flag%3!=0){
                        conditionA.await();
                    }
                    flag++;
                    System.out.println("A" + i);
                    conditionB.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }).start();


        new Thread(()->{
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    while(flag%3!=1){
                        conditionB.await();
                    }
                    flag++;
                    System.out.println("B" + i);
                    conditionC.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }).start();


        new Thread(()->{
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    while(flag%3!=2){
                        conditionC.await();
                    }
                    flag++;
                    System.out.println("C" + i);
                    conditionA.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }).start();
    }
}

Semaphore

```java
public class Main{
    
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphoreA=new Semaphore(1);
        Semaphore semaphoreB=new Semaphore(0);
        Semaphore semaphoreC=new Semaphore(0);
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    semaphoreA.acquire();
                    System.out.println("A"+i);
                    semaphoreB.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();


        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    semaphoreB.acquire();
                    System.out.println("B"+i);
                    semaphoreC.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();


        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    semaphoreC.acquire();
                    System.out.println("C"+i);
                    semaphoreA.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}