Java并发之ReentrantLock

一、ReentrantLock简介

　　ReentrantLock字面意义上理解为可重入锁。那么怎么理解可重入这个概念呢？或者说和我们经常用的synchronized又什么区别呢？

　　ReentrantLock可重入锁是一种递归无阻塞的同步锁机制，简单意思就是说可重入锁就是当前持有该锁的线程能够多次获取该锁，无需等待。它可以等同于synchronized的作用，但是它比synchronized更加的灵活，更加的强大，能够更好的降低死锁发生的概率。

二、ReentrantLock使用和Lock接口中的API介绍

　　2.1、构造方法

　　ReentrantLock是lock接口的实现类。

　　无参数构造。直接返回ReentrantLock锁的实例。

　　有参数构造。支持传入一个boolean类型的参数表示这个锁是公平锁还是非公平锁。ReentrantLock默认是非公平锁。设置参数为true表示为公平锁。

　　2.2、lock()方法

　　lock方法表示当前线程去获取锁。不能获取到锁则等待。需要注意的是ReentrantLock锁需要我们手动的释放锁，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

　　

         ReentrantLock lock = new ReentrantLock();
         lock.lock();//获取锁
         try{
             //处理业务
         }catch (Exception e){

         }finally {
             lock.unlock();//释放锁
         }    

　　2.3、tryLock()方法

　　由于lock方法获取锁以后只能一直等待。这样有些不太友好。提供了tryLock方法。该方法会提供一个boolean返回值。为true表示获取锁成功，为false则表示获取锁失败了。这样可以避免一直无脑的等待锁。同时tryLock提供了一个重载方法tryLock(long time, TimeUnit unit)。tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

         if (lock.tryLock()){
         try {
              //得到锁 处理业务
             } catch(Exception e){

             } finally {
                 lock.unlock();
             }
         }else{
             //没有获取到锁，先执行其他的任务
         }        

　　2.4、lockInterruptibly()方法。响应中断操作

　　当通过这个锁去获取锁的时候可以响应的中断操作，意思就是当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。这个过程叫做中断自己，会捕获到InterruptedException异常。注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。

三、ReentrantLock类简单使用

　　前面有说了该类主要是更加灵活的使用synchronized同步锁。

　

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.locks.ReentrantLock;

 public class TestReentrantLock {
     public static List<Integer> list = new ArrayList<>();
     public ReentrantLock lock = new ReentrantLock();
     public static void main(String[] args) {
         TestReentrantLock addThread = new TestReentrantLock();
         new Thread(){
             public void run(){
                 //addThread.insert(Thread.currentThread());
                 addThread.tryInsert(Thread.currentThread());
             }
         }.start();

         new Thread(){
             public void run(){
                 //addThread.insert(Thread.currentThread());
                 addThread.tryInsert(Thread.currentThread());
             }
         }.start();
     }

     /**
      * 只有一个线程能够对list集合进行增加操作
      */
     public void insert(Thread thread){

         lock.lock();
         try{
             System.out.println("当前线程:"+thread.getName()+"获取了锁");
             for (int i = 0;i < 10;i++){
                 list.add(i);
             }
         }catch (Exception e){

         }finally {
             System.out.println("当前线程:"+thread.getName()+"释放了锁");
             lock.unlock();
         }

     }

     /**
      * 尝试插入数据。如果当前不让插入数据。则去做其他业务
      * @param thread
      */
     public void tryInsert(Thread thread){
         if (lock.tryLock()){
             try{
                 System.out.println("当前线程:"+thread.getName()+"获取了锁");
                 for (int i = 0;i < 10;i++){
                     list.add(i);
                 }
             }catch (Exception e){

             }finally {
                 System.out.println("当前线程:"+thread.getName()+"释放了锁");
                 lock.unlock();
             }
         }else{
             System.out.println("线程"+thread.getName()+"获取锁失败");
         }
     }

 }

线程Thread-1获取锁失败
当前线程:Thread-0获取了锁
当前线程:Thread-0释放了锁

四、(Lock接口)ReentrantLock和synchronized的一些比较

　　4.1、Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现。

　　4.2、synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁。

　　4.3、Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断。

　　4.4、通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。