ReentrantLock

ReentrantLock

与sys相比，它具有如下特点

可中断
可以设置超时时间
可以设置为公平锁
支持多个条件变量

与sys一样，支持可重入

语法：

//获取锁
reentrantLock.lock();、

try{
           //临界区
}finally{
           //释放锁
     reentrantLock.unlock();
}

可重入：

可重入是指同一个线程首次获得这把锁，那么他是这把锁的拥有作者，因此有权利再次获得这把锁
如果不是可重入，那么第二次获得这把锁的时候，自己也会被锁挡住

public class Test {
    private  static ReentrantLock lock= new ReentrantLock();


    public static void main(String[] args) {
        lock.lock();
        try {
            System.out.println("mian");
            m1();
        }finally {
            lock.unlock();
        }


    }
    public static void m1(){
        lock.lock();
        try {
            System.out.println("m1");
            m2();
        }finally {
            lock.unlock();
        }
    }
    public static void m2(){
        lock.lock();
        try {
            System.out.println("m2");
        }finally {
            lock.unlock();
        }
    }


}

可打断

等待获取锁的过程中，会被阻塞，但是可以被打断等待，sys不可以

public class Test01 {
    private static ReentrantLock lock = new ReentrantLock();


    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            try {
                //尝试获得锁
                //如果其他线程鲜活的锁，这里被阻塞，但是可以被打断
                System.out.println("尝试获得锁");
                lock.lockInterruptibly();


            } catch (InterruptedException e) {
                System.out.println("获得锁失败");
                e.printStackTrace();
                return;
            }
            try{
                System.out.println("获得到锁");
            }finally {
                lock.unlock();
            }
        },"t1");




        //主线程先获得锁
        lock.lock();
        //这时候，t1线程等待获得锁
        t1.start() ;
        Thread.sleep(1000);
        t1.interrupt();
    }
}

锁超时

想获得锁的时候，因为其他线程没有释放锁，所以会等待，但是不会一直等待，超过一定时间就不等了

public class Test02 {
    private static ReentrantLock lock= new ReentrantLock();
    public static void main(String[] args) {
             Thread t1 = new Thread(()->{
                 System.out.println("尝试获得锁");
                 try {
                     if(!lock.tryLock(1, TimeUnit.SECONDS)){
                         System.out.println("获取不到锁");
                         return;
                     }
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                     System.out.println("获取不到锁");
                     return;
                 }
                 try{
                     System.out.println("获得到锁");
                 }finally {
                     lock.unlock();
                 }
             });
             lock.lock();
             //这时候，t1获取不到锁，1s 后  就直接返回了（主动）
             //当然在1s时间内，也可以直接被打断等待（被动）
             t1.start();

    }
}

公平锁

sys是不公平锁，Ree默认也是不公平的，但是可以设置成公平的
公平锁的本意是解决饥饿问题。

条件变量

synchronized 中也有条件变量，就是我们讲原理时那个waitSet休息室，当条件不满足时进入waitSet等待ReentrantLock的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的

这就好比synchronized是那些不满足条件的线程都在一间休息室等消息

而ReentrantLock支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒

使用流程：
await前需要获得锁
await执行后，会释放锁，进入conditionObject 等待
await的线程被唤醒（或打断、或超时)取重新竞争lock锁竞争lock锁成功后，从await后继续执行