一、前言
在此前《ReentrantLock基本介绍》这篇博客中已经介绍了ReentrantLock的基本使用,那在本篇博客中将会简要介绍下其内部的主要源码。
前提:对AbstractQueuedSynchronizer(简称AQS)有了解,不清楚的可以先去看看《AbstractQueuedSynchronizer源码——基本认识》
二、源码介绍
1、基本构造
在上面两篇博客中都有提到过ReentrantLock,ReentrantLock的功能实现依赖于AQS,下面只是截取的部分源码,详细的在后面说面。
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
// 下面的内部类,上锁、解锁最终是通过该对象操作
private final Sync sync;
/**
* Sync继承于AbstractQueuedSynchronizer
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
// 具体内容省略...
}
/**
* 非公平锁,继承了上面的Sync
*/
static final class NonfairSync extends Sync {
// 具体内容省略...
}
/**
* 公平锁,继承了上面的Sync
*/
static final class FairSync extends Sync {
// 具体内容省略...
}
/**
* 默认构造,可以看到是new的NonfairSync对象
*/
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* 带参构造,传true就会new FairSync对象
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
// 加锁
public void lock() {
sync.lock();
}
// 解锁
public void unlock() {
sync.release(1);
}
// 其他省略...
}
2、加锁与解锁
2.1、加锁
从上面代码可以看出ReentrantLock的加锁是调用了Sync中的lock方法,但是Sync中lock也是抽象方法,具体实现就得看其子类FairSync、NonfairSync。
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
// 抽象方法
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
...
}
protected final boolean tryRelease(int releases) {
...
}
}
2.1.1、公平锁
公平锁对应的FairSync类,可以看到在FairSync的lock方法中调用了AQS中的acquire方法,如果是看了AQS源码的就会知道,该方法是独占模式下获取资源的方法,这里就体现出了ReentrantLock是属于独占锁。
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
//...
}
再把AQS的方法源码贴出来,可以看到此方法里面首先会执行tryAcquire方法,在AQS中tryAcquire方法都是有AQS的子类自行设计实现(《AbstractQueuedSynchronizer源码——基本认识》有介绍),所以这里将会执行FairSync 中的tryAcquire方法。
// #AbstractQueuedSynchronizer
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
FairSync 中的tryAcquire方法:
static final class FairSync extends Sync {
//...
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取state
int c = getState();
// 为0说明资源已被释放,可以去尝试获取
if (c == 0) {
// hasQueuedPredecessors这个方法就是公平锁的实现
// 该方法做的事请就是在当前线程想要去获取资源前,判断在AQS的等待队列中他前面是否有正常等待的线程,
//有返回true,没有返回false
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) { // CAS设置state值为1
setExclusiveOwnerThread(current); // 若签到资源后,设置当前线程为资源拥有者
return true;
}
}
// 倘若state不为0,如果当前线程正好是资源拥有者(就是当前线程没释放锁,然后有来获取锁来了)
else if (current == getExclusiveOwnerThread()) {
// state值+1,这里就是体现了ReentrantLock的可重入性
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
上面代码中hasQueuedPredecessors()实现了公平锁,也就是说在线程获取资源之前先要检查等待队列,如果你前面还有人,那么你抢到了也没用(!hasQueuedPredecessors()等于false,不会进入if),在else if中则体现了可重入性,有用资源的时候再来获取资源,那么state值就会增加1。
2.1.2、非公平锁
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
// 尝试快速方式获取资源,state=0时CAS设置
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else // 不为0则acquire方法获取资源
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
// 尝试获取锁时这里调用的是Sync中的nonfairTryAcquire方法
return nonfairTryAcquire(acquires);
}
}
// #ReentrantLock.Sync
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
// 这里可以对比公平锁中,少了hasQueuedPredecessors方法去做判断,谁抢到就算谁的
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;
}
在非公平锁中上面代码可以看到,在获取锁时有个取巧的操作,就是通过CAS的特性如果state正好为0来快速判断,然后在tryAcquire中的区别就是少了hasQueuedPredecessors方法去做判断。
2.2、解锁
解锁对应unlock方法。
public void unlock() {
// 调用了AQS中的release
sync.release(1);
}
贴出AbstractQueuedSynchronizer中的release,方法中的释放方法tryRelease则是在ReentrantLock中的Sync实现。
// #AbstractQueuedSynchronizer
public final boolean release(int arg) {
// 这里
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
贴出ReentrantLock中的tryRelease。
// #ReentrantLock.Sync
protected final boolean tryRelease(int releases) {
// 获取state值并减去releases(releases=1)
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false; // 资源是否空闲,默认false
if (c == 0) {
// 如果state-1=0,那么就表示成功释放掉锁了,后面其他线程可以去获取资源了
free = true; // 置为true
// 资源拥有者置为null
setExclusiveOwnerThread(null);
}
// 否者将state重新赋值新的值,返回的free也将是false
// 所以之前提到过,ReentrantLock加了几次锁就得解锁几次,要不然锁一致将会是被占用状态
setState(c);
return free;
}
总的来说解锁其实就是将state的值置减1,当为0后这表示解锁成功。
三、小结
上面就是对ReentrantLock的源码基本介绍,大前提是得知道AQS的流程,了解后其实ReentrantLock的源码就不是什么问题了,再过来看也就是看看可重入性、公平、非公平具体是在哪体现出来的了。