我的jdk源码（二十三）：ReentrantLock类
一、概述
ReentrantLock类是在内部利用自己的内部类Sync继承了AbstractQueuedSynchronizer，实现了tryAcquire()方法，在这个方法中增强自己的功能，比如添加了重入和公平锁、非公平锁。ReentrantLock再将Sync作进一步的封装，开放出去Lock的接口。
ReentrantLock是通过在请求锁的时候判断CLH列表有没有比当前线程等待时间更久的线程来实现公平性的。当一个线程请求公平锁的时候，如果state为0，还需要在CHL中没有等待节点，或CHL首位就是当前线程，那么就可以使用CAS请求锁。否则请求直接失败。非公平锁没有这个限制，只要state为0,就可以使用CAS操作请求锁。非公平锁的吞吐量要比公平锁要高，因为公平锁就是完全要入队然后依次执行，在入队后线程会被park，到当前线程后需要unpark。线程之前的切换，资源准备等都是比较耗时的。非公平锁在在任务请求获取锁的时候如果正好锁被释放，则可以不用入队省去了线程阻塞唤醒。
二、源码分析
1. 类的声明
public class ReentrantLock implements Lock, java.io.Serializable
ReentrantLock类实现了Lock和Serializable接口，表示其实例是可序列化的琐。
2. 构造函数
// 构造一个 ReentrantLock 实例（非公平锁）
public ReentrantLock() {
sync = new NonfairSync();
}
// 构造一个 ReentrantLock 实例（指定是否公平）
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}3. 成员变量
//序列化标识id
private static final long serialVersionUID = 7373984872572414699L;
//同步器实例，可以是公平琐，也可以是非公平琐
private final Sync sync;4. 内部类-Sync类
//Sync也是一个抽象类，因为锁有非公平和公平的区别。
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
//非公平和公平锁的lock()方法有不同的实现。
abstract void lock();
//tryLock()在子类中实现，该方法是非公平的独占式获取同步状态。
//该方法首先判断同步状态是否被获取，如果没有，CAS获取同步状态并将锁的拥有者设为当前线程，如果有，判断获取锁的线程是否是当前线程，如果是，将同步值进行累加。
//成功获取锁的线程，再次获取锁，只是增加了同步值。
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;
}
//获取了多少次锁，同样也要释放多少次锁。
//当同步值不为0时，还是当前线程占有锁。
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
//是否被当前线程所占有
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
//得到锁的占有者
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
//获取锁的次数
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
//锁是否被获取
final boolean isLocked() {
return getState() != 0;
}
//反序列化操作
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}ReentrantLock通过将继承AQS的子类sync作为类成员变量来实现锁，sync实现AQS的抽象方法来管理同步状态。锁的获取和释放是通过修改 AQS 的 state 变量来实现的。lock 方法可以看做对 state 执行“加法”操作，而 unlock 可以看做对 state 执行“减法”操作，当 state 为 0 时，表示当前没有线程占用资源。
5. 内部类-NonfairSync类
//非公平锁的实现
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
//非公平锁加锁，acquire调用tryAcquire,tryAcquire调用nonfairTryAcquire
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}非公平锁的lock()方法步骤为：先尝试以 CAS 方式修改 state 的值，若修改成功，则表示成功获取到锁，将 owner 设为当前线程；否则就执行 AQS 中的 acquire 方法。
6. 内部类-FairSync类
//公平锁的实现
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
//lock()调用acquire(),acquire()调用tryAcquire(),公平锁和非公平锁的tryAcquire()的实现唯一不同
//就是加入了hasQueuesPredecessors(),通过判断当前节点是否有前驱节点，如果有则当前节点不是等待时间最长的线程
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
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;
}
}非公平锁相比，公平锁的不同之处在于增加了判断条件 hasQueuedPredecessors，即首先判断主队列中是否有其他线程在等待，当没有其他线程在排队时再去获取，否则获取失败。
公平锁和非公平锁的主要在于两个地方：
(1) 获取锁lock()方法的不同：非公平锁会直接进行一次CAS，如果CAS成功，就直接获取锁了。
(2) tryAcquire()方法实现的不同：当同步状态此时被释放的时候，state等于0，并没有任何线程占有锁，如果是公平锁，会判断队列中是否有线程等待获取锁，如果有的话，直接将自己构造成一个节点加入同步队列，但是非公平锁会直接CAS设置状态，不考虑同步队列中是否有其他线程等待获取锁。如果获取同步状态失败，会将自己构造成一个节点加入同步队列中，加入同步队列之后，等待前驱节点释放同步状态，唤醒自己，这后面的步骤公平锁和非公平锁是一样的。
7. ReentrantLock其他方法
//构造函数默认是非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//可选择实现公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//获取锁
public void lock() {
sync.lock();
}
//可中断式的获取锁
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
//尝试非阻塞的获取锁，调用方法之后立马返回，能获取返回true,不能获取返回false
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
//释放锁
public void unlock() {
sync.release(1);
}
//获取等待通知组件，该组件和当前锁绑定
public Condition newCondition() {
return sync.newCondition();
}
//锁被获取的次数
public int getHoldCount() {
return sync.getHoldCount();
}
//锁是否被当前线程所占有
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
//锁是否已经被获取
public boolean isLocked() {
return sync.isLocked();
}
//是否是公平锁
public final boolean isFair() {
return sync instanceof FairSync;
}
//获取锁的所有者
protected Thread getOwner() {
return sync.getOwner();
}
//是否有线程等待该锁
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
//查询给定线程是否在等待该锁
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
//查询等待锁的线程数
public final int getQueueLength() {
return sync.getQueueLength();
}
//返回等待锁的线程集合
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}三、总结
ReentrantLock类总的来说，就是利用内部类sync类的子类NonfairSync类和FairSync类来实现非公平琐与公平琐，sync类则是继承自AbstractQueuedSynchronizer类。
ReentrantLock类有以下几点特点：
1. 是一个可重入锁，能保证同一个线程多次加锁。
2. 可以实现公平琐和非公平琐，初始化的时候可以指定类型。
3. 默认是非公平琐，线程每次再加入同步队列之前，都会尝试获取琐。
4. ReentrantLock类实现的琐可以看作是synchronized的升级版，可以手动获取琐和释放锁，并且可以绑定多个条件（基于AQS的Condition）。
更多精彩内容，敬请扫描下方二维码，关注我的微信公众号【Java觉浅】，获取第一时间更新哦！
