前言
多线程知识中理解了ReentrantLock之后，对于整个AQS也会有大概的理解，后面再去看其它锁的源码就会比较容易。下面带大家一块来学习ReentrantLock源码。
概述
ReentrantLock是可重入的互斥锁，虽然具有与synchronized相同功能，但是会比synchronized更加灵活（具有更多的方法）。ReentrantLock底层基于AbstractQueuedSynchronized。有两种锁方式公平锁和非公平锁，公平锁指线程锁定后会进入队列进行排队等待至获得锁的使用权；而非公平锁指线程锁定后会尝试获取锁，如果获取失败则进入等待队列进行排队。
正文
应用场景
下面有这么一段代码，有10个线程对count进行累加，每个线程累加10000次，那么最终期望的输出值肯定是100000。
private static int count = 0;
private static void inrc() {
count++;
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int a=0;a<10000;a++){
inrc();
}
}).start();
}
TimeUnit.SECONDS.sleep(3);
System.out.println(count);
}
不加锁的情况，输出会不符合我们的预期。
使用ReentrantLock加锁。
private static Lock lock = new ReentrantLock();
private static int count = 0;
private static void inrc() {
try {
//加锁
lock.lock();
count++;
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int a=0;a<10000;a++){
inrc();
}
}).start();
}
TimeUnit.SECONDS.sleep(3);
System.out.println(count);
}
输出结果：符合预期
NonfairSync：lock方法
ReentrantLock默认为非公平锁，从其构造方式中可以看出。
public ReentrantLock() {
sync = new NonfairSync();
}
下面我们来追踪ReentrantLock的lock()方法，由于默认为非公平锁，所以当我们调用lock方法时，实际调用的是NonfairSync的lock方法
public void lock() {
sync.lock();
}
final void lock() {
//尝试通过CAS修改state值，如果此时成功的修改了state的值为1，则证明竞争到了锁资源
if (compareAndSetState(0, 1))
//将线程占用者属性设置为当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
//如果占用失败，则再次尝试，如果还失败则会加入队列进行等待
acquire(1);
}
由于是非公平锁，所以进入该方法时，会先尝试获取锁资源，通过CAS（可以保证原子性，即线程安全）设置state值为1，如果成功设置则是拿到了资源，否则调用acquire方法进行尝试。如果是公平锁的话直接调用acquire()方法；
AQS：acquire方法
public final void acquire(int arg) {
//tryAcquire(arg):再次尝试获取锁资源
//addWaiter(Node.EXCLUSIVE)：前面的判断如果获取不到锁资源，则将添加当前线程到队列中进行等待
//acquireQueued：自旋尝试获取锁资源
//selfInterrupt()：如果当前线程的状态被打断了，则将当前线程打断掉（只有当前线程有权限打断自己所在线程）
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
1、tryAcquire(arg)：这里会再次尝试是否能获取到锁资源，有可能当前拥有锁资源的线程就是自己所在的线程，那么这时候是支持锁重入的。
2、acquireQueued(addWaiter(Node.EXCLUSIVE), arg))：添加当前线程到队列中，并以自旋的方式尝试获取锁资源。
3、selfInterrupt()：当前线程的状态如果为打断状态，则将当前线程打断掉（只有当前线程有权限打断自己所在线程）
NonfairSync： tryAcquire方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
//获取当前线程
final Thread current = Thread.currentThread();
//获取state的状态看是否被占有
int c = getState();
//如果为0，则代表当前为被占有
if (c == 0) {
//通过CAS方式尝试修改其值进行资源占用
if (compareAndSetState(0, acquires)) {
//成功则将当前线程为资源拥有者
setExclusiveOwnerThread(current);
return true;
}
}
//判断资源拥有者与当前线程是否是同个，如果是则将state值进行累加，达到可重入的目的
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;
}
AQS：addWaiter方法
AQS中的队列结构为双向链表结构，每个节点为node对象，该对象拥有前置节点、后置节点属性；
private Node addWaiter(Node mode) {
//将当前线程封装成node
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
//判断链表的尾部节点是否为空，如果为空则证明整个队列没有值
Node pred = tail;
if (pred != null) {
//设置当前节点的前置节点
node.prev = pred;
//通过CAS的方式将当前节点与上个节点关联起来。通过CAS保证线程安全
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
AQS： acquireQueued方法
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//死循环
for (;;) {
//获取当前线程节点在队列中的前一个线程节点
final Node p = node.predecessor();
//判断其是否处于队列头部位置，如果是则代表快轮到自己了，进行尝试获取资源
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//判断当前线程的状态是否为等待中，如果是则返回true，不是则将状态设置为等待状态
if (shouldParkAfterFailedAcquire(p, node) &&
//阻塞并返回当前线程是否被打断标识
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
AQS：shouldParkAfterFailedAcquire方法
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
//如果上个节点处于等待状态，则代表当前的线程可以进行阻塞，因为上个线程都没获取资源，肯定不会轮到自己的，可以安心阻塞
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
//状态大于0，证明上个线程取消了，需要从队列中往前查一个未取消的
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
//将当前节点设置为等待状态
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
AQS：parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
//调用park方法进行阻塞，这样调用的是native方法，即调用内核态库中的函数
UNSAFE.park(false, 0L);
setBlocker(t, null);
}
AQS：cancelAcquire方法
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
//将当前线程置为null，方便gc
node.thread = null;
// Skip cancelled predecessors
//获取上个节点
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
// predNext is the apparent node to unsplice. CASes below will
// fail if not, in which case, we lost race vs another cancel
// or signal, so no further action is necessary.
Node predNext = pred.next;
// Can use unconditional write instead of CAS here.
// After this atomic step, other Nodes can skip past us.
// Before, we are free of interference from other threads.
//将线程状态设置为取消
node.waitStatus = Node.CANCELLED;
// If we are the tail, remove ourselves.
//如果当前线程位于队列的最后一个位置，由于取消了，所以要将上个队列位置的线程置为尾部
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
int ws;
//这一步只要将上个线程与下个线程进行关联，移除当前线程在队列的位置
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
//释放下一个线程阻塞状态
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
AQS：unparkSuccessor
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
//释放线程的阻塞状态
LockSupport.unpark(s.thread);
}
NonfairSync：unlock方法
通过前面的步骤，我们知道处于队列中的线程都处于阻塞状态，持有资源的线程执行完之后，需要调用unlock方法将队列中的下一个线程唤醒，并将自己从队列中进行移除。
public void unlock() {
sync.release(1);
}
AQS：release方法
public final boolean release(int arg) {
//判断是否能释放，因为ReentrantLock是重入锁，每次重入时state会加1，所以如果state-1不等于0的话，需要多次的unlock才能达到释放资源。比如同个线程中调用了两次lock，需要调用两次unlock才能释放资源。
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
//将下个节点唤醒
unparkSuccessor(h);
return true;
}
return false;
}
ReentrantLock：tryRelease方法
protected final boolean tryRelease(int releases) {
//将state减一
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果为0释放资源
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
//不为0，证明之前有过重入的情况，需要等该线程的所有unlock方法执行完毕后，state等于0才能释放
setState(c);
return free;
}
AQS：unparkSuccessor方法
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
//将当前线程状态设置为0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
//查找下个节点，状态不为取消的
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
//唤醒
LockSupport.unpark(s.thread);
}
总结
下面画了流程图，帮助大家更好的理解。
非公平锁
公平锁
解锁
