一、锁绑定多个条件Condition概述

• ReentrantLock 用来实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized 要么随机唤醒一个线程，要么唤醒全部线程。

二、锁绑定多个条件Condition示例代码

• 示例需求

示例需求：
多线程之间按顺序调用，实现A->B->C 三个线程启动，要求如下：
A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
紧接着
A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
。。。。
一共遍历3次

• 示例代码

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 *  @description:  1、lock有什么好处？
 *                   锁绑定多个条件Condition：即实现分组唤醒需要唤醒的线程，可以精确唤醒，而不是像synchronized 要么随机唤醒一个线程，要么唤醒全部线程。
 *                 2、示例需求：
 *                   多线程之间按顺序调用，实现A->B->C 三个线程启动，要求如下：
 *                   A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
 *                   紧接着
 *                   A线程 打印1次，  B线程 打印2次，  C线程 打印3次，
 *                   。。。。
 *                   一共遍历3次
 * @author: xz
 */
class MyResource{
    private int number =1;//A线程用1表示，B线程用2表示，C线程用3表示

    private Lock lock=new ReentrantLock();
    private Condition c1=lock.newCondition();
    private Condition c2=lock.newCondition();
    private Condition c3=lock.newCondition();

    public void print1(){
        lock.lock();
        try {
            //1、判断!=1,说明A线程不输出，等待
            while(number !=1){
                c1.await();
            }
            //2、A线程输出1次
            for(int i=1;i<=1;i++){
                System.out.println(Thread.currentThread().getName()+"\t"+number);
            }
            //3、先修改标志位,然后A线程通知B线程
            number=2;
            c2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void print2(){
        lock.lock();
        try {
            //1、判断!=2,说明B线程不输出，等待
            while(number !=2){
                c2.await();
            }
            //2、B线程输出2次
            for(int i=1;i<=2;i++){
                System.out.println(Thread.currentThread().getName()+"\t"+number);
            }
            //3、先修改标志位,然后B线程通知C线程
            number=3;
            c3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public void print3(){
        lock.lock();
        try {
            //1、判断!=3,说明C线程不输出，等待
            while(number !=3){
                c3.await();
            }
            //2、B线程输出3次
            for(int i=1;i<=3;i++){
                System.out.println(Thread.currentThread().getName()+"\t"+number);
            }
            //3、先修改标志位,然后C线程通知A线程
            number=1;
            c1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}
public class SyncAndReentrantLockDemo {
    public static void main(String[] args) {
        MyResource myResource=new MyResource();

        new Thread(()->{
            for (int i=1;i<=3;i++){
                myResource.print1();
            }
        },"A线程").start();

        new Thread(()->{
            for (int i=1;i<=3;i++){
                myResource.print2();
            }
        },"B线程").start();

        new Thread(()->{
            for (int i=1;i<=3;i++){
                myResource.print3();
            }
        },"C线程").start();
    }
}

• 输出结果如下图：