ReentrantLock了解吗？是公平锁吗？

ReentrantLock(可重入锁) 实现了Lock接口,是一个可重入且独占式的锁，和synchronized关键字类似，不过ReentrantLock更灵活、强大，增加了轮询、超时、中断、公平锁和非公平锁等高级功能。

重入锁指在同一线程中，外部方法获得锁之后，内层递归方法依然可以获得该锁，如果锁不具备重入性，那么当同一个线程两次获取锁的时候就会发生死锁。

独占锁指该锁在同一时刻只能被一个线程获取，而获取锁的其他线程只能在同步队列中等待。

ReentrantLock默认使用非公平锁，也可以通过构造器显式指定公平锁。

• 公平锁：锁被释放之后，先申请的线程先得到锁。性能较差，公平锁为了保证时间上的绝对顺序，上下文切换更频繁。
• 非公平锁：锁被释放之后，后申请的线程可能会先获取到锁，是随机或者按照其他优先级排序的。性能更好，但可能会导致某些线程无法获取到锁。

synchronized与ReentrantLock的异同

• 两者都是可重入锁

• synchronized依赖于JVM而ReentrantLock依赖于API,synchronized是依赖于JVM的，而ReentrantLock是JDK层面实现的也就是API层面，需要lock()和unlock()方法配合try/finally语句块来完成。

• synchronized不需要用户手动释放锁，ReentrantLock则需要用户手动释放锁。

• ReentrantLock比synchronized增加了一些高级功能：

  等待可中断:ReentrantLock提供了一种能够中断等待锁的线程的机制，通过lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。

  可实现公平锁: ReentrantLock可以指定是公平锁还是非公平锁。而synchronized只能是非公平锁。所谓的公平锁就是先等待的线程先获得锁。ReentrantLock默认情况是非公平的，可以通过ReentrantLock类的ReentrantLock(boolean fair)构造方法来指定是否是公平的。

  可实现选择性通知(锁可以绑定多个条件) : synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制。ReentrantLock类当然也可以实现，但是需要借助于Condition接口与newCondition()方法。

ReentrantLock如何避免死锁：响应中断、可轮询锁、定时锁

(1)响应中断：在synchronized中如果有一个线程尝试获取一把锁，则其结果是要么获取锁继续执行，要么继续等待。ReentrantLock还提供了可响应中断的可能，即在等待锁的过程中，线程可以按需取消对锁的请求。

(2)可轮询锁:通过boolean tryLock()获取锁。如果有可用锁，则获取该锁并返回true,如果无可用锁，则立即返回false。

(3)定时锁：通过boolean tryLock(long time,TimeUnit unit) throws InterruptedException获取锁。如果在指定的时间内获取到了可用锁，且当前线程未被中断，则获取该锁并返回true。如果在指定的时间内获取不到可用锁，则将禁用当前线程，并且在发生如下三种情况之前，该线程一直处于休眠状态。

• 当前线程获取到了可用锁并返回true。
• 在当前线程进入此方法时若设置了该线程的中断状态，或者当前线程在获取锁时被中断，则将抛出InterruptedException，并清除当前线程的已中断状态。
• 当前线程获取锁的时间超过了指定的等待时间，将返回false。如果设定的时间小于或等于0，则该方法将完全不等待。

ReentrantLock抢占锁的三种方法

• lock()方法用于阻塞抢锁，抢不到锁时线程会一直阻塞。
• tryLock()方法用于尝试抢锁，该方法有返回值，如果成功就返回true，如果失败(锁已被其他线程获取)就返回false。此方法无论如何都会立即返回，在抢不到锁时，线程不会像调用lock()方法那样一直被阻塞。
• tryLock(long time,TimeUnit unit)方法和tryLock()方法类似，只不过这个方法在抢不到锁时会阻塞一段时间。如果在阻塞期间获取到锁就立即返回true，超时则返回false。

(1)使用lock()方法

 public void lock()

模板代码如下：

 ReentrantLock lock = new ReentrantLock();lock.lock();    //1:抢占锁try {//2:抢锁成功，执行临界区代码} finally {lock.unlock();//3:释放锁}

注意：

• 释放锁操作lock.unlock()必须在try-catch结构的finally块中执行，否则，如果临界区代码抛出异常，锁就有可能永远得不到释放。

• 抢占锁操作lock.lock()必须在try语句块之外，而不是放在try语句块之内。

  原因一：lock()方法没有声明抛出异常，所以可以不包含到try块中。

  原因二：lock()方法并不一定能够抢占锁成功，如果没有抢占成功，当然也就不需要释放锁，而且在没有占有锁的情况下去释放锁，可能会导致运行时异常。

• 在抢占锁操作lock.lock()和try语句之间不要插入任何代码，避免抛出异常而导致释放锁操作lock.unlock()执行不到，导致锁无法被释放。

(2)调用tryLock()方法非阻塞抢锁

public boolean tryLock()

lock()是阻塞式抢占，在没有抢到锁的情况下，当前线程会阻塞。

tryLock()是非阻塞式抢占，在没有抢到锁的情况下，当前线程会立即返回，不会被阻塞。

//创建锁对象
ReentrantLock lock = new ReentrantLock();
if(lock.tryLock()){//1:尝试抢占锁try {//2：抢锁成功，执行临界区代码} finally {lock.unlock();  //3:释放锁}
}else{//4:抢锁失败，执行后备动作
}

3)调用tryLock(long time,TimeUnit unit)方法抢锁

public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException

tryLock(long timeout, TimeUnit unit) throws InterruptedException方法用于限时抢锁，该方法在抢锁时会进行一段时间的阻塞等待，其中的time参数代表最大的阻塞时长，unit参数为时长的单位。

//创建锁对象
ReentrantLock lock = new ReentrantLock();
try {if(lock.tryLock(1, TimeUnit.SECONDS)){//1:尝试抢占锁try {//2：抢锁成功，执行临界区代码} finally {lock.unlock();  //3:释放锁}}else{//4:限时抢锁失败，执行后备动作}
} catch (InterruptedException e) {e.printStackTrace();
}

。

Condition

与Object对象的wait、notify两类方法类似，基于Lock显式锁，JUC也提供了一个用于线程间进行“等待-通知”方式实现的接口java.util.concurrent.locks.Condition。

(1)Lock接口的主要方法

public interface Condition{//方法1：等待，使当前线程加入等待队列中，并释放当前锁//当其他线程调用signal()时，等待队列中的某个线程会被唤醒，重新去抢锁void await() throws InterruptedException;//方法2：通知。此方法在功能上与Object.notify()语义等效//唤醒一个在await()等待队列中的线程void signal();//方法3：通知全部。唤醒await()等待队列中所有的线程，此方法与Object.notifyAll()语义上等效void signalAll();//方法3：限时等待。此方法与await()语义上等效//不同点在于，在指定time等待超时后，如果没有被唤醒，线程将中止等待//线程等待超时返回false,其他情况返回trueboolean await(long time, TimeUnit unit) throws InterruptedException
}

Condition对象的signal(通知)方法和同一个对象的await(等待)方法是一一配对使用的，也就是说，一个Condition对象的signal(或signalAll)方法不能去唤醒其他Condition对象上的await线程。

Condition对象是基于显式锁的，所以不能独立创建一个Condition对象，而是需要借助于显式锁实例去获取其绑定的Condition对象。

不过，每一个Lock显式锁实例都可以有任意数量的Condition对象。具体来说，可以通过lock.newCondition()方法去获取一个与当前显式锁绑定的Condition实例，然后通过该Condition实例进行“等待-通知”方式的线程间通信。

 public class ReentrantLockCondition {//创建一个显式锁static Lock lock=new ReentrantLock();//获取一个显式锁绑定的Condition对象static private Condition condition=lock.newCondition();​//等待线程执行异步目标任务static class WaitTarget implements Runnable{@Overridepublic void run() {lock.lock();//1：抢占锁try {System.out.println("我是等待方");condition.await();//2：开始等待，并且释放锁System.out.println("收到通知，等待方继续执行");} catch (InterruptedException e) {e.printStackTrace();}finally {lock.unlock();//释放锁}​}}//通知线程的异步目标任务static class NotifyTarget implements Runnable{@Overridepublic void run() {lock.lock(); //3:抢锁try {System.out.println("我是通知方");condition.signal(); //4:发送通知System.out.println("发出通知了，但是线程还没有立马释放锁");} finally {lock.unlock();  //5:释放锁之后，等待线程才能获得锁}}}​public static void main(String[] args) throws InterruptedException {//创建等待线程Thread waitThread = new Thread(new WaitTarget(), "WaitThread");//启动等待线程waitThread.start();Thread.sleep(2000);//等待一会​//创建通知线程Thread notifyThread = new Thread(new NotifyTarget(), "NotifyThread");//启动通知线程notifyThread.start();}}