ReentrantLock意思为可重入锁，指的是一个线程能够对一个临界资源重复加锁。
借用美团技术博客的一张图说明它和Synchronized的区别
区别
ReentrantLock的主要结构
ReentrantLock没有直接继承AbstractQueuedSynchronizer，而是Sync继承的。Sync又是个抽象类，有NonfairSync和FairSync两个子类。可以看到默认的构造函数是非公平锁，另一个构造函数则指定公平/非公平。
全局变量sync在构造函数里被赋值，在加锁、解锁等操作的时候使用sync里面的API
在开始之前要知道公平锁和非公平锁的区别
公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。
优点：所有的线程都能得到资源，不会饿死在队列中。
缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大
非公平：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
缺点：可能会导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。
加锁API
public void lock() {
sync.lock();
}
FairSync实现
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
// 调用AQS的acquire，AQS的acquire又会调用子类的tryAcquire
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 获取AQS的同步状态，如果锁没有被占用（0没占用，1占用），那么获取锁
if (c == 0) {
// 如果没有其他线程比当前线程等待的时间更长，那么就把AQS的同步状态置为1
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
// 设置同步状态成功后，把当前线程设置为独占线程，获取锁成功
setExclusiveOwnerThread(current);
return true;
}
}
// 锁被占用，并且是自己占用的话，就加重入次数，否则，获取锁失败返回false
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
NonfairSync实现
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
// 非公平锁，直接占用锁，
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else // 如果CAS更新同步状态失败再去acquire，acquire又会调用tryAcquire
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 锁没没有被占用则获取锁
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 获取锁的是自己则累加重入次数
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
响应中断获取锁
public void lockInterruptibly() throws InterruptedException {
// 调用AQS的acquireInterruptibly，如果当前线程没有被中断则获取锁
sync.acquireInterruptibly(1);
}
有返回值的获取锁
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 没有其他线程获取锁，则将当前线程设置为独享线程，返回true
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 当前线程已经拥有锁了，重入
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// state设置为重入的层数
setState(nextc);
return true;
}
// 没拿到锁返回false
return false;
}
}
释放锁API
释放锁是不分公平和非公平的,release是AQS的方法，不允许子类重写。但是其中的tryRelease强制子类重写
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
// 释放锁
if (tryRelease(arg)) {
// 如果还有头节点，并且头节点的waitStatus不是初始值，则唤醒后继节点的线程
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
// 当前state-releases=还剩下的重入层数
int c = getState() - releases;
// 如果不是当前线程独占，那么不允许当前线程释放锁
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果重入层数是0了，那么就代表当前线程没锁了，free=true
if (c == 0) {
free = true;
// 清空独占线程
setExclusiveOwnerThread(null);
}
// 设置state，不管state是0还是非0
setState(c);
// 返回free
return free;
}
