👳我亲爱的各位大佬们好
♨️本篇文章记录的为 ReentrantLock 相关内容，适合在学Java的小白,帮助新手快速上手,也适合复习中，面试中的大佬🙉🙉🙉。
♨️如果文章有什么需要改进的地方还请大佬不吝赐教❤️🧡💛
👨🔧 个人主页 : 阿千弟
@[toc]
ReentrantLock
ReentrantLock 的底层是通过 AbstractQueuedSynchronizer 实现
类的继承关系
ReentrantLock 实现了 Lock 接口，Lock 接口中定义了 lock 与 unlock 相关操作，并且还存在newCondition 方法，表示生成一个条件。
public class ReentrantLock implements Lock, java.io.Serializable
类的构造函数
- ReentrantLock () 型构造函数
默认是采用的非公平策略获取锁
public ReentrantLock() {
// 默认非公平策略
sync = new NonfairSync();
}
- ReentrantLock (boolean) 型构造函数
可以传递参数确定采用公平策略或者是非公平策略，参数为 true 表示公平策略，否则，采用非公平策略:
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
类的内部类 : Sync、NonfairSync、FairSync
ReentrantLock 总共有三个内部类，并且三个内部类是紧密相关的，下面先看三个类的关系。
ReentrantLock 有一个 Sync 属性，sync 有俩子类 NonfairSync 和 FairSync 。
说明: ReentrantLock 类内部总共存在 Sync、NonfairSync、FairSync 三个类，NonfairSync 与FairSync 类继承自 Sync 类，Sync 类继承自 AbstractQueuedSynchronizer抽象类。下面逐个进行分析。
Sync源码分析
abstract static class Sync extends AbstractQueuedSynchronizer {
// 序列号
private static final long serialVersionUID = xxx;
// 获取锁
abstract void lock();
// 非公平方式获取
final boolean nonfairTryAcquire(int acquires) {
// 当前线程
final Thread current = Thread.currentThread();
// 获取状态
int c = getState();
if (c == 0) {
// 表示没有线程正在竞争该锁
if (compareAndSetState(0, acquires)) {
// 比较并设置状态成功，状态0表示锁没有被占用
// 设置当前线程独占
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;
}
// 试图在共享模式下获取对象状态，此方法应该查询是否允许它在共享模式下获取对象状态，如果允许，则获取它
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() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
// 新生一个条件
final ConditionObject newCondition() {
return new ConditionObject();
}
// Methods relayed from outer class
// 返回资源的占用线程
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
}
}
NonfairSync源码分析
NonfairSync 类继承了 Sync 类，表示采用非公平策略获取锁，其实现了 Sync 类中抽象的 lock 方法，源码如下
// 非公平锁
static final class NonfairSync extends Sync {
// 版本号
private static final long serialVersionUID = xxx;
// 获得锁
final void lock() {
if (compareAndSetState(0, 1)) // 比较并设置状态成功，状态0表示锁没有被占用
// 把当前线程设置独占了锁
setExclusiveOwnerThread(Thread.currentThread());
else // 锁已经被占用，或者set失败
// 以独占模式获取对象，忽略中断
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
说明：从 lock 方法的源码可知，每一次都尝试获取锁，而并不会按照公平等待的原则进行等待，让等待时间最久的线程获得锁。
FairSyn 源码分析
FairSync 类也继承了 Sync 类，表示采用公平策略获取锁，其实现了 Sync 类中的抽象 lock 方法，源码如下:
// 公平锁
static final class FairSync extends Sync {
// 版本序列化
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
// 以独占模式获取对象，忽略中断
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();
if (c == 0) {
// 状态为0
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
// 不存在已经等待更久的线程并且比较并且设置状态成功
// 设置当前线程独占
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
// 状态不为0，即资源已经被线程占据
// 下一个状态
int nextc = c + acquires;
if (nextc < 0) // 超过了int的表示范围
throw new Error("Maximum lock count exceeded");
// 设置状态
setState(nextc);
return true;
}
return false;
}
}
说明：跟踪 lock 方法的源码可知，当资源空闲时，它总是会先判断 sync 队列 (AbstractQueuedSynchronizer中的数据结构) 是否有等待时间更长的线程，如果存在，则将该线程加入到等待队列的尾部，实现了公平获取原则。其中，FairSync 类的lock 的方法调用如下，只给出了主要的方法。
说明：可以看出只要资源被其他线程占用，该线程就会添加到 sync queue 中的尾部，而不会先尝试获取资源。这也是和 Nonfair 最大的区别，Nonfair 每一次都会尝试去获取资源，如果此时该资源恰好被释放，则会被当前线程获取，这就造成了不公平的现象，当获取不成功，再加入队列尾部。
核心函数分析
对比公平锁和非公平锁的 tryAcquire()方法的实现代码，其实差别就在于非公平锁获取锁时比公平锁中少了一个判断 !hasQueuedPredecessors()
hasQueuedPredecessors() 中判断了是否需要排队，导致公平锁和非公平锁的差异如下：
公平锁：公平锁讲究先来先到，线程在获取锁时，如果这个锁的等待队列中已经有线程在等待，那么当前线程就会进入等待队列中；
非公平锁：不管是否有等待队列，如果可以获取锁，则立刻占有锁对象。也就是说队列的第一个排队线程在unpark()，之后还是需要竞争锁（存在线程竞争的情况下）
通过分析 ReentrantLock 的源码，可知对其操作都转化为对 Sync 对象的操作，由于 Sync 继承了 AQS，所以基本上都可以转化为对 AQS 的操作。如将 ReentrantLock 的 lock 函数转化为对 Sync 的 lock 函数的调用，而具体会根据采用的策略 (如公平策略或者非公平策略) 的不同而调用到 Sync 的不同子类。
所以可知，在 ReentrantLock 的背后，是 AQS 对其服务提供了支持
如果这篇【文章】有帮助到你💖，希望可以给我点个赞👍，创作不易，如果有对
Java后端或者对spring感兴趣的朋友,请多多关注💖💖💖
👨🔧 个人主页 : 阿千弟
