006-condition精准通知

 *   多个线程之间按顺序调用，实现 A->B->C
 *   三个线程启用，实现顺序如下
 *   AA打印5次，BB打印10次，CC打印15次
 *   ....来10轮
 * 

如何去做呢？
线程操作资源类，首先，把资源类写出来。

然后，再看要求，要实现精准通知，a干完活去通知b，b干完活去通知c。

也就是说跟synchronize的有点像，但是不一样。
这就要用到，condition。
condition可以new多个，也就是有多个钥匙。
在设一个标志位。
这样的话，就可以在a完成后，将标志位改一下，
唤醒b，b做完后，修改标志位，唤醒c。
到c结束。

具体代码如下：

package com.bai.juc.day01;

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

/*
 *   多个线程之间按顺序调用，实现 A->B->C
 *   三个线程启用，实现顺序如下
 *   AA打印5次，BB打印10次，CC打印15次
 *   ....来10轮
 * */
class ThreadOrder {
    private final Lock lock = new ReentrantLock();
    //三把钥匙
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    //标志位
    int flag = 1;

    public void print5() {
        //判断 干活 通知
        lock.lock();
        try {
            //判断
            while (flag != 1) {
                condition1.await();
            }
            //干活
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //通知
            flag = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void print10() {
        //判断 干活 通知
        lock.lock();
        try {
            //判断
            while (flag != 2) {
                condition2.await();
            }
            //干活
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "\t" + i);
            }
            //通知
            flag = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void print15() {
        //判断 干活 通知
        lock.lock();
        try{
            //判断
            while (flag!=3){
                condition3.await();
            }
            //干活
            for (int i = 0; i < 15; i++) {
                System.out.println(Thread.currentThread().getName()+"\t"+i);
            }
            //通知
            flag=1;
            condition1.signal();
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    }
}


public class Order {
    public static void main(String[] args) {
        ThreadOrder threadOrder = new ThreadOrder();
        new Thread(() -> {
            threadOrder.print5();
        }, "a").start();
        new Thread(() -> {
            threadOrder.print10();
        }, "b").start();
        new Thread(() -> {
            threadOrder.print15();
        }, "c").start();
        new Thread(() -> {
            threadOrder.print5();
        }, "a1").start();
        new Thread(() -> {
            threadOrder.print10();
        }, "b1").start();
        new Thread(() -> {
            threadOrder.print15();
        }, "c1").start();
    }
}