多线程交替打印，循环输出ABBCCC

多线程交替打印，循环输出ABBCCC

1. 使用synchronized/wait/notifyAll

/**
 * 按照ABBCCC...的顺序打印20次
 */
public class ABBCCC_Wait {

    public static void main(String[] args) {
        ABBCCCPrinter printer = new ABBCCCPrinter(1, 5);
        new Thread(() -> {
            printer.print("A", 1, 2);
        }, "t1").start();

        new Thread(() -> {
            printer.print("B", 2, 3);
        }, "t2").start();

        new Thread(() -> {
            printer.print("C", 3, 1);
        }, "t3").start();
    }
}

/**
 * 打印类
 */
class ABBCCCPrinter{
    /**
     * 公共标记位
     */
    private int flag;

    /**
     * 循环次数
     */
    private int loopNumber;

    public ABBCCCPrinter(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }

    /**
     * 打印方法
     * @param str : 打印字符串
     * @param waitFlag : 等待标记位
     * @param nextFlag : 下一个标记位
     */
    public void print(String str, int waitFlag, int nextFlag){
        for (int i = 0; i < loopNumber; i++) {
            synchronized (this){
                // while循环防止虚假唤醒
                while (flag != waitFlag){
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int j = 0; j < waitFlag; j++) {
                    System.out.print(str);
                }
                flag = nextFlag;
                this.notifyAll();

            }
        }
    }
}

2. 使用lock/await/signalAll

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

public class ABBCCC_Await {

    public static void main(String[] args) {
        final Lock lock = new ReentrantLock();
        final Condition conditionA = lock.newCondition();
        final Condition conditionB = lock.newCondition();
        final Condition conditionC = lock.newCondition();
        ABBCCC_Await_Printer printer = new ABBCCC_Await_Printer(1, 5);
        new Thread(() -> {
            printer.print("A", 1, 2, lock, conditionA, conditionB);
        }, "t1").start();

        new Thread(() -> {
            printer.print("B", 2, 3, lock, conditionB, conditionC);
        }, "t2").start();

        new Thread(() -> {
            printer.print("C", 3, 1, lock, conditionC, conditionA);
        }, "t3").start();
    }
}


class ABBCCC_Await_Printer {

    /**
     * 公共标记
     */
    private int flag;

    /**
     * 循环次数
     */
    private int loopNumber;

    public ABBCCC_Await_Printer(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }


    /**
     * @param str : 打印字符串
     * @param waitFlag ： 等待标记位
     * @param nextFlag ： 下一个标记位
     * @param waitCondition ：等待条件
     * @param signalCondition  ：唤醒
     */
    public void print(String str, int waitFlag, int nextFlag,
                      Lock lock,
                      Condition waitCondition,
                      Condition signalCondition) {
        for (int i = 0; i < loopNumber; i++) {
            lock.lock();
            try {
                // while循环防止虚假唤醒
                while (flag != waitFlag){
                    try {
                        waitCondition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                for (int j = 0; j < waitFlag; j++) {
                    System.out.print(str);
                }
                flag = nextFlag;
                signalCondition.signalAll();
            }finally {
                lock.unlock();
            }

        }



    }
}