ReentrantLock 精确唤醒线程

Synchronized和ReentrantLock的区别

• 原始构成：synchronized是关键字，属于JVM层面，底层通过monitor对象来完成，wait/notify等方法也依赖于monitor，只有在同步块或方法中才能调用wait/notify等方法；Lock是个类，是api层面的锁。
• 使用方法：synchronized 不需要手动释放锁，当synchronized 代码执行完后系统会自动让线程释放对锁的占用；Lock需要手动开锁和释放锁，不释放则会造成死锁。通过lock.lock()和lock.unlock()结合try...catch...finally语句块来完成。
• 等待是否可中断：synchronized 不可中断，除非运行完毕或异常中断；Lock可中断，设置超时方法tryLock(long timeout,TimeUnit unit)，调用 interrupt() 方法中断
• 加锁是否公平：synchronized 是非公平锁；ReentrantLock 既可以是公平锁，也可以是非公平锁，根据参数设置
• 锁绑定多个条件Condition：synchronized 没有这个功能，ReentrantLock 用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像 synchronized 似的随即唤醒一个或者全部唤醒

ReentrantLock 如何精确唤醒线程

   设定场景：三个线程按顺序调用，实现线程A→B→C依次启动，其中A打印 1 次，B打印 2 次，C打印 3 次，再如此循环 3 次

class ShareRes{
    private int num = 1; //A:1,B:2,C:3
    private ReentrantLock lock = new ReentrantLock();
    private Condition conditionA  = lock.newCondition();
    private Condition conditionB  = lock.newCondition();
    private Condition conditionC  = lock.newCondition();
    void print1(){
        lock.lock();
        try {
            while (num != 1){
                conditionA.await();
            }
            for (int i = 1; i <= 1; i++) {
                System.out.println(Thread.currentThread().getName()+"  "+i);
            }
            num = 2;
            conditionB.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    void print2(){
        lock.lock();
        try {
            while (num != 2){
                conditionB.await();
            }
            for (int i = 1; i <= 2; i++) {
                System.out.println(Thread.currentThread().getName()+"  "+i);
            }
            num = 3;
            conditionC.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    void print3(){
        lock.lock();
        try {
            while (num != 3){
                conditionC.await();
            }
            for (int i = 1; i <= 3; i++) {
                System.out.println(Thread.currentThread().getName()+"  "+i);
            }
            num = 1;
            conditionA.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

public class LockTraditionDemo {

    public static void main(String[] args) {
        final ShareRes res = new ShareRes();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    res.print1();
                }
            }
        },"线程A").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    res.print2();
                }
            }
        },"线程B").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    res.print3();
                }
            }
        },"线程C").start();
    }
}

----------------------------------
线程A  1
线程B  1
线程B  2
线程C  1
线程C  2
线程C  3
线程A  1
线程B  1
线程B  2
线程C  1
线程C  2
线程C  3
线程A  1
线程B  1
线程B  2
线程C  1
线程C  2
线程C  3

     ReentrantLock 绑定了三个条件对象，可以精确唤醒线程。