ReentrantLock源码解析

引言

相信接触过java并发编程的对锁都不陌生，本文将给出ReentrantLock（可重入锁）的具体使用以及相关源码的分析。

先看具体的使用吧：

public class ReentrantLockTest {

private static int number = 0;

ReentrantLock reentrantLock = new ReentrantLock();

public void writer() {
reentrantLock.lock();//获取锁
try {
number++;
} finally {
reentrantLock.unlock();//释放锁
}
}

public void reader() {
reentrantLock.lock();
try {
System.out.println(Thread.currentThread() + " " + number);
} finally {
reentrantLock.unlock();
}
}

@Test
public void run() {
for (int i = 0; i < 100; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(100);
} catch (Exception e) {
e.printStackTrace();
}
writer();
reader();
}
});
thread.run();
}
reader();
}
}

从上面的代码可以看出，可通过ReentrantLock的lock()方法来获取锁，unLock()方法来释放锁。

ReentrantLock的实现依赖于AbstractQueuedSynchronizer（简称AQS），接下来就源码来做一些简要的分析。

ReentrantLock源码分析

开始分析源码之前我们先来看看ReentrantLock的类图（本文给出的类图仅包含待分析的源码部分）：



ReentrantLock相关源码分析：

ReentrantLock分为公平锁和非公平锁（不知道这两种锁的区别的读者可自行百度，我在此不再做详细的赘述），我们首先来分析公平锁的相关内容。

如何声明公平锁

ReentrantLock提供带参构造方法可以声明公平锁

//不带参构造方法，只能声明非公平锁，在使用的时候需要注意
public ReentrantLock() {
sync = new NonfairSync();
}
//带参构造方法，fair == ture：公平锁，fair == false：非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}

公平锁加锁

加锁方法lock()调用轨迹如下：

ReentrantLock.lock();

FairSync.lock();

AbstractQueuedSynchronizer.acquire(int arg);

ReentrantLock.tryAcquire(int acquires)

到tryAcquire方法调用时才真正加锁，我们着重看一下该方法的源码：

protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();//读取锁状态state值
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;
}//当前线程再次进入锁（可重入，state表示该线程进入的次数）
return false;
}

公平锁解锁

解锁方法unlock()调用轨迹如下：

ReentrantLock.unlock();

AbstractQueuedSynchronizer.release(int arg);

Sync.tryRelease(int releases)

tryRelease方法被调用时，释放锁，它的源码如下：

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;// state == 0的时候表示当前没有线程获取到锁，并且，锁释放成功一定是当前线程的state == 0
}

接下来我们来看看非公平锁，非公平锁的释放与公平锁完全一样，在这里就不再做赘述了，我们着重看一下非公平锁的加锁调用。

调用轨迹如下：

ReentrantLock.lock();

NonfairSync.lock();

AbstractQueuedSynchronizer.compareAndSetState(int expect, int update)

我们来看看加锁部分的源码：

final void lock() {
if (compareAndSetState(0, 1))//判断当前是否已经有线程获取该锁
setExclusiveOwnerThread(Thread.currentThread());//若没有线程占用该锁，把锁分配给当前线程
else
acquire(1);//尝试获得锁，获取不到锁需要到队列中等待
}

protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);//原子操作方式更新state变量，保证线程安全
}

后记

到这里，ReentrantLock的源码分析告一段落，后续文章还会给出AQS相关分析，分析它是如何来保证线程获取锁的顺序等。