三个线程循环打印ABC各10次

package com.hangzhou.springcloud.service.impl;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadPrintTest {
    public static void main(String[] args) {
        ThreadResource threadResource=new ThreadResource();
        new Thread(()->{
            for (int i=0;i<10;i++){
                threadResource.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                threadResource.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                threadResource.printC();
            }
        },"C").start();
    }
}

class ThreadResource{

    private ReentrantLock lock=new ReentrantLock();
    private Condition conditionA=lock.newCondition();
    private Condition conditionB=lock.newCondition();
    private Condition conditionC=lock.newCondition();

    private volatile int num=1;

    public void printA(){
        lock.lock();

        //多线程不能用if 防止出现并发异常 java.util.ConcurrentModifyException
        try {
            while (num!=1){
                conditionA.await();
            }
            System.out.println(Thread.currentThread().getName()+"线程打印A");
            num=2;
            conditionB.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printB(){
        lock.lock();
        try {
            while (num!=2){
                conditionB.await();
            }
            System.out.println(Thread.currentThread().getName()+"线程打印B");
            num=3;
            conditionC.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void printC(){
        lock.lock();
        try {
            while (num!=3){
                conditionC.await();
            }
            System.out.println(Thread.currentThread().getName()+"线程打印C");
            num=1;
            conditionA.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

输出结果:
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C
A线程打印A
B线程打印B
C线程打印C

Process finished with exit code 0