并发编程（三）—— ReentrantLock的用法

　　ReentrantLock是Java并发包中提供的一个可重入的互斥锁。ReentrantLock和synchronized在基本用法，行为语义上都是类似的，同样都具有可重入性。只不过相比原生的Synchronized，ReentrantLock增加了一些高级的扩展功能，比如它可以实现公平锁，同时也可以绑定多个Conditon。

可重入性/公平锁/非公平锁

可重入性

所谓的可重入性，就是可以支持一个线程对锁的重复获取，原生的synchronized就具有可重入性，一个用synchronized修饰的递归方法，当线程在执行期间，它是可以反复获取到锁的，而不会出现自己把自己锁死的情况。ReentrantLock也是如此，在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。

公平锁/非公平锁

　　所谓公平锁,顾名思义，意指锁的获取策略相对公平，当多个线程在获取同一个锁时，必须按照锁的申请时间来依次获得锁，排排队，不能插队；非公平锁则不同，当锁被释放时，等待中的线程均有机会获得锁。synchronized是非公平锁，ReentrantLock默认也是非公平的，但是可以通过带boolean参数的构造方法指定使用公平锁，但非公平锁的性能一般要优于公平锁。

　　synchronized是Java原生的互斥同步锁，使用方便，对于synchronized修饰的方法或同步块，无需再显式释放锁。而ReentrantLock做为API层面的互斥锁，需要显式地去加锁解锁。采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。

class X {
    private final ReentrantLock lock = new ReentrantLock();
    // ...

    public void m() {
      lock.lock();  // 加锁
      try {
        // ... 函数主题
      } finally {
        lock.unlock() //解锁
      }
    }
}

源码分析

　　接下来我们从源码角度来看看ReentrantLock的实现原理，它是如何保证可重入性，又是如何实现公平锁的。

1、无参构造器（默认为非公平锁）

public ReentrantLock() {
     sync = new NonfairSync();//默认是非公平的
}

sync是ReentrantLock内部实现的一个同步组件，它是Reentrantlock的一个静态内部类，继承于AQS。

2、带布尔值的构造器（是否公平）

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();//fair为true，公平锁；反之，非公平锁
}

此处可以指定是否采用公平锁，FailSync和NonFailSync亦为Reentrantlock的静态内部类，都继承于Sync。

3、lock()

public void lock() {
        sync.lock();//代理到Sync的lock方法上
}

Sync的lock方法是抽象的，实际的lock会代理到FairSync或是NonFairSync上（根据用户的选择来决定，公平锁还是非公平锁）

4、unlock()

public void unlock() {
        sync.release(1);//释放锁
}

释放锁，调用sync的release方法。

5、tryLock()

Lock lock = ...;
if(lock.tryLock()) {
     try{
         //处理任务
     }catch(Exception ex){

     }finally{
         lock.unlock();   //释放锁
     }
}else {
    //如果不能获取锁，则直接做其他事情
}

tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false。

6、newCondition()

public Condition newCondition() {
        return sync.newCondition();
}

获取一个conditon，ReentrantLock支持多个Condition

7、await（）

public class MyService {

    private Lock lock = new ReentrantLock();
    private Condition condition=lock.newCondition();
    public void testMethod() {

        try {
            lock.lock();
            System.out.println("开始wait");
            condition.await();
            for (int i = 0; i < 5; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName()
                        + (" " + (i + 1)));
            }
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }

}

通过创建Condition对象来使线程wait，必须先执行lock.lock方法获得锁

8、signal（）

public void signal() {
        try {
            lock.lock();
            condition.signal();
        } finally {
            lock.unlock();
        }
}

condition对象的signal方法可以唤醒wait线程

9、创建多个condition对象

　　一个condition对象的signal（signalAll）方法和该对象的await方法是一一对应的，也就是一个condition对象的signal（signalAll）方法不能唤醒其他condition对象的await方法

ABC循环打印20遍

 package main.java.Juc;

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

 /*
  * 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
  *    如：ABCABCABC…… 依次递归
  */
 public class TestABCAlternate {

     public static void main(String[] args) {
         AlternateDemo ad = new AlternateDemo();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 for (int i = 1; i <= 20; i++) {
                     ad.loopA(i);
                 }
             }
         }, "A").start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 for (int i = 1; i <= 20; i++) {
                     ad.loopB(i);
                 }
             }
         }, "B").start();

         new Thread(new Runnable() {
             @Override
             public void run() {
                 for (int i = 1; i <= 20; i++) {
                     ad.loopC(i);
                     System.out.println("-----------------------------------");
                 }
             }
         }, "C").start();
     }

 }

 class AlternateDemo{

     private int number = 1; //当前正在执行线程的标记

     private Lock lock = new ReentrantLock();
     private Condition condition1 = lock.newCondition();
     private Condition condition2 = lock.newCondition();
     private Condition condition3 = lock.newCondition();

     /**
      * @param totalLoop : 循环第几轮
      */
     public void loopA(int totalLoop){
         lock.lock();
         try {
             //1. 判断
             if(number != 1){
                 condition1.await();
             }
             //2. 打印
             for (int i = 1; i <= 1; i++) {
                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
             }
             //3. 唤醒
             number = 2;
             condition2.signal();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void loopB(int totalLoop){
         lock.lock();
         try {
             //1. 判断
             if(number != 2){
                 condition2.await();
             }
             //2. 打印
             for (int i = 1; i <= 1; i++) {
                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
             }
             //3. 唤醒
             number = 3;
             condition3.signal();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

     public void loopC(int totalLoop){
         lock.lock();
         try {
             //1. 判断
             if(number != 3){
                 condition3.await();
             }
             //2. 打印
             for (int i = 1; i <= 1; i++) {
                 System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
             }
             //3. 唤醒
             number = 1;
             condition1.signal();
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
             lock.unlock();
         }
     }

 }

运行结果：

代码分析：

　　三个线程分别循环20次调用loopA、loopB、loopC打印，但是不确定是哪个方法先被调用到,如果是loopB先调用，则loopB方法先获取到锁，loopA和loopC等待锁，此时线程执行标记number=1，代码84行处为true,则condition2.await();如果需要唤醒此线程，则需要用condition2来唤醒，此时线程交出锁；

　　如果loopA获取了锁，loopB和loopC等待锁，此时线程执行标记number=1，代码63行处为false,则执行67行打印，打印完则用condition2.signal()唤醒打印loopB的线程，接着loopB的线程去打印B，线程loopB打印完毕去唤醒打印loopC的线程，打印完loopC再唤醒loopA，如此循环20次。

总结

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

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

3、Lock类可以创建Condition对象，Condition对象用来是线程等待和唤醒线程，需要注意的是Condition对象的唤醒的是用同一个Condition执行await方法的线程，所以也就可以实现唤醒指定类的线程