基于JDK11从源码角度剖析可重入锁ReentrantLock的获取锁和解锁

ReentrantLock是可重入的独占锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞而被放入该锁的AQS阻塞队列里面。

ReentrantLock是JUC包提供的显式锁的一个基础实现类，实现了Lock接口。我们先来看下ReentrantLock的类图，如下：

从类图可知，ReentrantLock 是使用AQS来实现的，ReentrantLock 的构造函数根据参数来决定其内部是一个公平还是非公平锁，默认是非公平锁。构造函数代码如下：

 public ReentrantLock() {sync = new NonfairSync();
}public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();
}

获取锁原理

lock()方法

当一个线程调用lock()方法时，说明该线程希望获取该锁。如果锁当前没有被其他线程占用并且当前线程之前没有获取过该锁，则当前线程会获取到该锁，然后设置当前锁的拥有者为当前线程，并设置AQS的状态值为1，然后直接返回。如果当前线程之前已经获取过该锁，则这次只是简单地把AQS的状态值加1后返回。如果该锁已经被其他线程持有，则调用该方法的线程会被放入AQS队列后阻塞挂起。lock()方法源码如下：

 public void lock() {sync.acquire(1);}

从代码可知，lock()委托给了sync类，根据创建ReentrantLock构造函数选择sync的实现是NonfairSync还是FairSync，这个锁是一个非公平锁或者公平锁,最终调用的是AQS的acquire(）方法，代码如下：

   public final void acquire(int arg) {//step1:调用子类重写的tryAcquire（）方法，tryAcquire返回false会把当前线程放入AQS阻塞队列if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

我们先来看下非公平锁的tryAcquire(）方法实现,源码如下：

    static final class NonfairSync extends Sync {private static final long serialVersionUID = 7316153563782823691L;/*** 非公平锁抢占的钩子方法* ReentrantLock“非公平”性体现在这里：如果占用锁的线程刚释放锁，state置为0，* 而排队等待锁的线程还未唤醒，新来的线程就直接抢占了该锁，那么就“插队”了。* 举一个例子，当前有三个线程A、B、C去竞争锁，假设线程A、B在排队，* 但是后来的C直接进行CAS操作成功了，拿到锁开开心心地返回了，那么线程A、B只能乖乖看着。* @param acquires* @return*/protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}}
abstract static class Sync extends AbstractQueuedSynchronizer {/*** 核心思想是当前线程尝试获取锁的时候，如果发现锁的状态位是0，* 就直接尝试将锁拿过来，然后执行setExclusiveOwnerThread()，根本不管同步队列中的排队节点。*/@ReservedStackAccessfinal boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();//先直接获得锁的状态int c = getState();//step2:当前AQS状态值为0if (c == 0) {// 如果内部队列首节点的线程执行完了，它会将锁的state设置为0，// 当前抢锁线程的下一步就是直接进行抢锁，不管不顾//返现state是空的，就直接拿来加锁使用，根本不考虑后面继承者的存在if (compareAndSetState(0, acquires)) {//step1：利用CAS自旋方式判断当前state确实为0，然后设置为acquire（1），// 这是原子性操作，保证线程安全setExclusiveOwnerThread(current);// 设置当前执行的线程，直接返回truereturn true;}}else if (current == getExclusiveOwnerThread()) {   //step3： 当前线程是该锁持有者//step2： 当前的线程和执行中的线程是同一个，也就意味着可重入操作int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);//表示当前锁被1个线程重复获取了nextc次return true;}  //step4：// 表示没有成功获取当前锁，进入排队过程return false;}    .....
} 

在step2中会会查看当前锁的状态值是否为0，为0则说明当前该锁空闲，那么就尝试CAS获取该锁，将AQS的状态值从0设置为1，并设置当前锁的持有者为当前线程然后返回，true。如果当前状态值不为0则说明该锁已经被某个线程持有，所以step3查看当前线程是否是该锁的持有者，如果当前线程是该锁的持有者，则状态值加1，然后返回true，这里需要注意，nextc<0说明可重入次数溢出了。如果当前线程不是锁的持有者则返回false，然后其会被放入AQS阻塞队列。ReentrantLock 作为非公平锁时其抢占流程可以用下图表示：

介绍完ReentrantLock的非公平锁，接下来再来看看ReentrantLock的公平锁的tryAcquire ()策略，代码如下：

static final class FairSync extends Sync {/*** 公平抢占的钩子方法* 首先判断是否有后继节点，如果有后继节点，并且当前线程不是锁的占有线程，* 钩子方法就返回false，模板方法会进入排队的执行流程，可见公平锁是真正公平的。*/@ReservedStackAccessprotected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();//获取锁状态int c = getState();//step5： 当期AQS 状态值为0if (c == 0) {// step6：有后继接地那就返回，公平行策略if (!hasQueuedPredecessors() &&compareAndSetState(0, acquires)) {setExclusiveOwnerThread(current);return true;}}// step7 :当前线程是该锁持有者else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0)throw new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}}

从代码可知，公平的tryAcquire策略与非公平的类似，不同之处在于，代码step6在设置CAS前添加了hasQueuedPredecessors方法，该方法是实现公平性的核心代码，代码如下:

    public final boolean hasQueuedPredecessors() {Node h, s;if ((h = head) != null) {if ((s = h.next) == null || s.waitStatus > 0) {s = null; // traverse in case of concurrent cancellationfor (Node p = tail; p != h && p != null; p = p.prev) {if (p.waitStatus <= 0)s = p;}}if (s != null && s.thread != Thread.currentThread())return true;}return false;}

从代码可知，hasQueuedPredecessors的执行场景大致如下：
（ 1）如果(h = head) != null 不成立，说明头节点和尾节点要么是同一个节点，要么h头节点是null，此时hasQueuedPredecessors()返回false，表示没有后继节点。
（ 2）当(h = head) != null成立时，进一步检查head.next是否为null或者head.next的节点状态是否大于0，如果head.next为null或者head.next的节点状态大于0，head.next设置为null，然后查找是否有非头节点和非尾节点的线程处于等待状态的，有的话把head.next设置为正在等待的线程。
（ 3）当(h = head) != null成立时，head.next节点不为空且head.next不是当前线程时，就返回true，表示有后继节点，否则就返回false，表示没有后继节点。
ReentrantLock公平独占锁的抢占流程如下：

lockInterruptibly()方法

该方法与lock（）方法类似，它的不同在于，它对中断进行响应，就是当前线程在调用该方法时，如果其他线程调用了当前线程的interrupt（）方法，则当前线程会抛出InterruptedException异常，然后返回。

public void lockInterruptibly() throws InterruptedException {sync.acquireInterruptibly(1);}public final void acquireInterruptibly(int arg)throws InterruptedException {// 如果当前线程被中断，则直接抛出异常if (Thread.interrupted())throw new InterruptedException();//尝试获取资源if (!tryAcquire(arg))//调用AQS可被中断的方法doAcquireInterruptibly(arg);}

释放锁原理

尝试释放锁，如果当前线程持有该锁，则调用该方法会让该线程对该线程持有的AQS状态值减1，如果减去1后当前状态值为0，则当前线程会释放该锁，否则仅仅减1而已。如果当前线程没有持有该锁而调用了该方法则会抛出IllegalMonitorStateException异常，代码如下：

 public void unlock() {sync.release(1);
}
public final boolean release(int arg) {if (tryRelease(arg)) { //释放锁的钩子方法的实现//队列头节点Node h = head;if (h != null && h.waitStatus != 0)//唤醒后继线程unparkSuccessor(h);return true;}return false;
}