ReentrantLock类图
基于jdk1.8的源码分析
说明：本篇文章以公平锁（FairSync）说明，非公平锁的原理和公平锁大部分雷同，很多代码是提取在抽象类共用的，实现更简单，搞懂了公平锁的源码及原理，即可理解非公平锁
加锁过程
执行流程图
源码解析
从ReentrantLock的lock方法跟进来，选择公平锁的实现，发现底层调用的是java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire方法
/**
* 主要做三件事 1.tryAcquire：尝试通过CAS获取一次锁，详情可见下面源码分析
* 2.addWaiter：将当前线程加入到储存等待获取锁的线程的双向链表中
* 3.acquireQueued:通过自旋的方式，判断当前队列节点是否可以获取锁
*/
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
下面我们按照执行顺序，一个个的分析，首先看java.util.concurrent.locks.ReentrantLock.FairSync#tryAcquire方法
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 等于0，表示当前没有线程占用锁；否则表示有线程占用锁
if (c == 0) {
// 1.判断队列中是否有线程在排队；2.如果没有，则通过CAS尝试修改state状态，修改成功就获得锁
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 判断正在占用锁的线程是否当前线程，是的话，state+1,用来保证可重入性
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
再看下java.util.concurrent.locks.AbstractQueuedSynchronizer#addWaiter方法
// 将新节点和当前线程关联并且入队列
private Node addWaiter(Node mode) {
// 基于当前线程创建一个节点,设置关联线程和模式(独占 or 共享)
Node node = new Node(Thread.currentThread(), mode);
// 获取队列的尾节点
Node pred = tail;
if (pred != null) {
// 如果尾节点不为空,说明队列已经初始化过,则把当前节点的前一个节点指向尾节点
node.prev = pred;
// 同时当前节点作为新的尾节点
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 尾节点为空,说明队列还未初始化,需要初始化head节点并入队新节点
enq(node);
return node;
}
再看下java.util.concurrent.locks.AbstractQueuedSynchronizer#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;
}
// 如果获取锁失败，则当前线程阻塞，继续保持自旋
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
acquireQueued方法自旋图解
解析下内部方法shouldParkAfterFailedAcquire的源码
/**
* 判断当前线程获取锁失败之后是否需要挂起.
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//前驱节点的状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
// 前驱节点状态为signal,返回true
return true;
// 前驱节点状态为CANCELLED
if (ws > 0) {
// 从队尾向前寻找第一个状态不为CANCELLED的节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 将前驱节点的状态设置为SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
/**
* 挂起当前线程,返回线程中断状态并重置
*/
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
线程入队后成为新的尾节点，此时必须保证他前面的节点（即之前的尾节点）等待状态waitStatus是SIGNAL，SIGNAL表示当前一个节点保存的线程对象获取到锁后会唤醒改节点。所以shouldParkAfterFailedAcquire会先判断当前节点的前驱是否状态符合要求，若符合则返回true，然后调用parkAndCheckInterrupt，将自己挂起。如果不符合，再看前驱节点是否>0(CANCELLED)，若是那么向前遍历直到找到第一个符合要求的前驱，若不是则将前驱节点的状态设置为SIGNAL。
整个流程中，如果前驱结点的状态不是SIGNAL，那么自己就不能安心挂起，需要去找个安心的挂起点，同时可以再尝试下看有没有机会去尝试竞争锁。
最终队列可能会如下图所示
释放锁的过程
执行流程图
源码解读
从ReentrantLock的unlock方法跟进来，发现底层调用的是
java.util.concurrent.locks.AbstractQueuedSynchronizer#release方法
public final boolean release(int arg) {
// 尝试释放锁，如果失败，说明已经重入了，则返回释放失败
if (tryRelease(arg)) {
Node h = head;
// 如果队列中头节点不为空，且等待状态不为0，则说明队列中有线程在等待，需要释放该线程的锁
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
java.util.concurrent.locks.ReentrantLock.Sync#tryRelease方法源码解读
protected final boolean tryRelease(int releases) {
// 当前锁状态减1
int c = getState() - releases;
// 当前线程不等于持有锁的线程，则直接抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 状态为0，则表示锁释放成功
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 重新设置状态
setState(c);
return free;
}
java.util.concurrent.locks.AbstractQueuedSynchronizer#unparkSuccessor方法解读
// 唤醒节点的后继节点(如果存在的话)。
private void unparkSuccessor(Node node) {
/*
* 如果状态是消极的(即，可能需要信号)，试着在信号发出的预期中明确。如果此操作失败，或者状态通过等待线程改变，也没有关系。
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* 帮助后继的节点释放锁，后继节点通常就是下一个节点。但如果被取消或明显为null，则从尾部往回遍历，以找到实际的未取消的后继对象
*/
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);
}
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/130214.html
