ReentrantLock

        相对于synchronized它具备如下特点

  * 可中断（即可以打断一个线程在等待的状态，避免一直等待从而导致的死锁）

  * 可以设置超时时间（synchronized获取锁时，如果不能获得锁，那么就会进入entryList去等待了，不会说等待一段时间就放弃了。ReentrantLock设置一个超时时间，如果规定时间内获得不到锁就会放弃，从而去执行一些其他的逻辑）

  * 可以设置为公平锁（而不是让这些线程随机去争抢，是先到先得的一种方式，防止饥饿现象：即有些线程一直抢不到锁）

  * 支持多个条件变量（synchronized只有一个条件变量：waitset，所有不满足条件的都在这一个集合里面等待。而调用notifyAll()这个集合里面都被唤醒了。Reentrantlock:有多个条件变量，可以根据不同的条件去细分，唤醒的时候也不用全部唤醒了。）

  * 与synchronized一样都支持可重入。

ReentrantLock的可重入性

import java.util.concurrent.locks.ReentrantLock;

public class test {

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {

        lock.lock();//获得锁,不可打断的
        try {
            //临界区
            System.out.println("1");
            m1();
        }finally {
            lock.unlock();//最后释放锁
        }
    }

    public static void m1(){
        lock.lock();//获得锁
        try {
            //临界区
            System.out.println("2");
            m2();
        }finally {
            lock.unlock();//最后释放锁
        }
    }

    public static void m2(){
        lock.lock();//获得锁
        try {
           //临界区
            System.out.println("3");
        }finally {
            lock.unlock();//最后释放锁
        }
    }
}

等待可打断

import java.util.concurrent.locks.ReentrantLock;

public class test {

    private static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() ->{
            try {
                //如果没有竞争，那么此方法就会获取到lock对象锁，如果有线程获得到锁就进入阻塞队列，可以被其他线程使用 interrupt 方法打断  lock得到的锁是不可等待打断的
                System.out.println("尝试获取锁");
                lock.lockInterruptibly();
            }catch (InterruptedException e) {
                e.printStackTrace();
                System.out.println("没有获得锁，返回");
                return;
            }
            try {
                //临界区
                System.out.println("获得到锁");
            }finally {
                lock.unlock();//最后释放锁
            }
        },"t1");

        lock.lock();
        t1.start();

        Thread.sleep(1000);
        System.out.println("打断t1");
        t1.interrupt();
    }

   
}

设置超时等待

tryLock():表示尝试获得锁，如果获得不到锁就返回false.

 

这个是设置等待时间为1秒，而且这个方法和lockInterruptibly()方法一样可以被打断的。 

ReentrantLock设置为公平锁

公平锁一般没有必要（的确可以解决饥饿问题），但是会降低并发度。

ReentrantLock 条件变量 

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

public class test {

    static boolean hasCigarette = false;
    static boolean hasTakeout = false;
    static ReentrantLock lock = new ReentrantLock();

    static Condition waitCigaretteSet = lock.newCondition();
    static Condition waitTakeoutSet = lock.newCondition();

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
           lock.lock();
           try {
               System.out.println("有没有烟？"+hasCigarette);
               while (!hasCigarette){
                   System.out.println("没有烟...先歇会儿");
                   try {
                       waitCigaretteSet.await();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
               System.out.println("可以开始干活了");

           }finally {
               lock.unlock();
           }
        },"小南").start();

        new Thread(() -> {
            lock.lock();
            try {
                System.out.println("外卖到没？"+hasCigarette);
                while (!hasTakeout){
                    System.out.println("外卖没到...先歇会儿");
                    try {
                        waitTakeoutSet.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("可以开始干活了");
            }finally {
                lock.unlock();
            }
        },"小女").start();

        Thread.sleep(1000);
        new Thread(()->{
            lock.lock();
            try {
                hasTakeout =true;
               waitTakeoutSet.signal();
            }finally {
                lock.unlock();
            }
        },"送外卖的").start();

        Thread.sleep(1000);
        new Thread(()->{
            lock.lock();
            try {
                hasCigarette =true;
                waitCigaretteSet.signal();
            }finally {
                lock.unlock();
            }
        },"送烟的").start();

    }

}

lock() 与 trylock()的区别

lock加锁失败后就会等待，当下一次被唤醒的时候又会去加锁。而trylock()只会尝试加锁一次，失败了就返回false.