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()，根本不管同步队列中的排队节点。
*/
@ReservedStackAccess
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//先直接获得锁的状态
int c = getState();
//step2:当前AQS状态值为0
if (c == 0) {
// 如果内部队列首节点的线程执行完了，它会将锁的state设置为0，
// 当前抢锁线程的下一步就是直接进行抢锁，不管不顾
//返现state是空的，就直接拿来加锁使用，根本不考虑后面继承者的存在
if (compareAndSetState(0, acquires)) {
//step1：利用CAS自旋方式判断当前state确实为0，然后设置为acquire（1），
// 这是原子性操作，保证线程安全
setExclusiveOwnerThread(current);
// 设置当前执行的线程，直接返回true
return true;
}
}
else if (current == getExclusiveOwnerThread()) { //step3： 当前线程是该锁持有者
//step2： 当前的线程和执行中的线程是同一个，也就意味着可重入操作
int nextc = c + acquires;
if (nextc < 0) // overflow
throw 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，模板方法会进入排队的执行流程，可见公平锁是真正公平的。
*/
@ReservedStackAccess
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//获取锁状态
int c = getState();
//step5： 当期AQS 状态值为0
if (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 cancellation
for (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;
}
