(多线程) 按序打印 (leetcode1114)

题目描述：

我们提供了一个类：

public class Foo {
  public void one() { print("one"); }
  public void two() { print("two"); }
  public void three() { print("three"); }
}

三个不同的线程将会共用一个 Foo 实例。

线程 A 将会调用 one() 方法
线程 B 将会调用 two() 方法
线程 C 将会调用 three() 方法
请设计修改程序，以确保 two() 方法在 one() 方法之后被执行，three() 方法在 two() 方法之后被执行。

示例：

示例 1:

输入: [1,2,3]
输出: "onetwothree"
解释:
有三个线程会被异步启动。
输入 [1,2,3] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 two() 方法，线程 C 将会调用 three() 方法。
正确的输出是 "onetwothree"。
示例 2:

输入: [1,3,2]
输出: "onetwothree"
解释:
输入 [1,3,2] 表示线程 A 将会调用 one() 方法，线程 B 将会调用 three() 方法，线程 C 将会调用 two() 方法。
正确的输出是 "onetwothree"。
说到底就是线程通信，保证线程有序，方法有很多，提供两种思路

上代码，拿去即可运行：

   

 package com.onlyqi.upup01.Thread02;
     
    import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
     
    public class Test01 {
        //通信对象
        private int number = 1;
        //声明锁
        private Lock lock = new ReentrantLock();
        //声明钥匙 A
        private Condition conditionA = lock.newCondition();
        //声明钥匙 B
        private Condition conditionB = lock.newCondition();
        //声明钥匙 C
        private Condition conditionC = lock.newCondition();
     
        public void printA(int j){
            try {
                lock.lock();
                while (number != 1){
                    conditionA.await();
                }
                System.out.println("===============================:one");
     
                //开始打印 B
                number = 2;
                //唤醒 B
                conditionB.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public void printB(int j){
            try {
                lock.lock();
                while (number != 2){
                    conditionB.await();
                }
                System.out.println("===============================:two");
                //开始打印 C
                number = 3;
                //唤醒 C
                conditionC.signal();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public void printC(int j){
            try {
                lock.lock();
                while (number != 3){
                    conditionC.await();
                }
                System.out.println("===============================:three");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
        public static void main(String[] args) {
            Test01 demoClass = new Test01();
     
            new Thread(() ->{
                demoClass.printB(2);
            }, "second 线程").start();
     
            new Thread(() ->{
                    demoClass.printA(1);
            }, "first 线程").start();
     
            new Thread(() ->{
                    demoClass.printC(3);
            }, "third线程").start();
        }
     
    }

运行结果：

 我要刷300道算法题，第101道