ReentrantLock 基于 AQS 独占模式实现了非公平和公平的独占可重入锁。
从结构上看， ReentrantLock 内部实现了AQS 的一个 Sync ，然后又衍生了两个子类，FairSync 和 NonfairSync 分别实现了获取锁的公平和非公平策略。
从 ReentrantLock 的构造器可以看出，默认是使用非公平锁，可以通过fair 参数来指定使用公平锁。
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
AQS 的 state 被作为 ReentrantLock 的锁可重入次数。
我们先来看一下非公平锁和公平锁的主要实现方法。
一、非公平锁
锁的入口方法是 lock。lock和 tryAcquire 方法都是NonfailSync 重写了 AQS 中的方法。nonfairTryAcquire则是 在 他的父类Sync 中实现的方法。
从tryAcquire源码中可以看出他的几个特点是如何实现的：
- 独占：通过
setExclusiveOwnerThread来设置独占线程，当其他线程要获取锁时，进行校验 - 可重入：通过维护 state变量int nextc = c + acquires ，来记录同一个线程获取锁的次数
- 非公平：当一个线程请求非公平的锁时，如果在发出请求的同时该锁的状态变为可用，那么这个线程将跳过AQS等待队列中所有等待的线程直接获得这个锁
final void lock() {
//通过 CAS 将 state 改为 1，尝试获取锁
if (compareAndSetState(0, 1))
//设置独占锁的线程为当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
//调用 AQS 的 acquire 方法
acquire(1);
}
//这里的逻辑就和 AQS 中分析的一样了，主要不同在于 tryAcquire
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
//其他线程尝试获取锁失败之后，就添加到等待队列中
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
//非公平锁获取策略
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//第一次获取锁，设置ExclusiveOwnerThread为当前线程，返回 true
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//若当前线程不是第一次获取锁，则state+1
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
//如果 state<0说明可重入次数溢出了，抛出 error
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
//如果已经有线程获取锁，而且不是当前线程，那么直接返回 false
return false;
}
ReentrantLock 的 tryLock 方法默认是调用的非公平锁策略，但是和 NonfairSync.lock 不同的是，他不会使当前线程阻塞：
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
二、公平锁
和 NonfairSync 一样，FairSync 也是重写了 lock 和 tryAcquire。
独占和可重入的实现都和 NonfairSync 一样。我们主要来看一下他是如何实现公平的：
和非公平锁的不同之处在于tryAcquire调用了hasQueuedPredecessors，而这个方法是 AQS 中的。
该方法会查询是否有任何线程等待获取的时间长于当前线程，如果有的话就返回 true，然后 tryAcquire 方法返回 false，进入acquireQueued自旋然后挂起线程。
final void lock() {
acquire(1);
}
//这里的逻辑就和 AQS 中分析的一样了，主要不同在于 tryAcquire
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
//其他线程尝试获取锁失败之后，就添加到等待队列中
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//如果队列中有节点在排队，则跳出返回 false，然后挂起线程
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
//返回 true 表示头结点后有节点在排队
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
//当队列不为空，或者h.next为空或者当前线程不是头结点next的线程，返回 true
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
三、释放锁
/**
* Attempts to release this lock.
* 尝试释放锁
* <p>If the current thread is the holder of this lock then the hold
* count is decremented. If the hold count is now zero then the lock
* is released. If the current thread is not the holder of this
* lock then {@link IllegalMonitorStateException} is thrown.
* 如果当前线程持有锁，那么 count-1。
如果 count=0，那么就释放锁
如果当前线程没有持有锁，那么抛出异常 IllegalMonitorStateException
*
*/
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
//当 c=0，释放锁成功，返回 true，调用 unpark 唤醒后面的线程
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//这个方法是在 ReentrantLock 中重写的
protected final boolean tryRelease(int releases) {
//先将 C 减去释放的资源
int c = getState() - releases;
//当前线程没有持有锁，则抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//当 c减到0，则释放锁，返回 true
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
原理弄清楚了，顺便总结了几点Synchronized和ReentrantLock的区别：
- Synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现；
- Synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过
ReentrantLock#isLocked判断； - Synchronized是非公平锁，ReentrantLock是可以是公平也可以是非公平的；
- Synchronized是不可以被中断的，而
ReentrantLock#lockInterruptibly方法是可以被中断的； - 在发生异常时Synchronized会自动释放锁（由javac编译时自动实现），而ReentrantLock需要开发者在finally块中显示释放锁；
- ReentrantLock获取锁的形式有多种：如立即返回是否成功的tryLock(),以及等待指定时长的获取，更加灵活；
- Synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁（上文有说），而ReentrantLock对于已经在等待的线程一定是先来的线程先获得锁；