目录
简介
ReentrantLock加锁流程图示
ReentrantLock解锁流程图示
队列中node数据的流转
addWaiter
acquireQueued的shouldParkAfterFailedAcquire方法
release
扩展cancelAcquire方法
简介
ReentrantLock是一个可重入且独占式的锁，它具有与使用synchronized监视器锁相同的基本行为和语义，但与synchronized关键字相比，它更灵活、更强大，增加了轮询、超时、中断等高级功能。ReentrantLock，顾名思义，它是支持可重入锁的锁，是一种递归无阻塞的同步机制。除此之外，该锁还支持获取锁时的公平和非公平选择。
ReentrantLock是一个可重入且独占式的锁，它具有与使用synchronized监视器锁相同的基本行为和语义，但与synchronized关键字相比，它更灵活、更强大，增加了轮询、超时、中断等高级功能。ReentrantLock，顾名思义，它是支持可重入锁的锁，是一种递归无阻塞的同步机制。除此之外，该锁还支持获取锁时的公平和非公平选择。
synchronized与ReentrantLock的区别：https://segmentfault.com/a/1190000039091031
ReentrantLock加锁流程图示
ReentrantLock解锁流程图示
下面根据源码，探究队列中数据的整体流转：
队列中node数据的流转
addWaiter
通过添加到队列的源码中可以看到，tail不为空时，CAS将当前节点的prev设置为tail节点，然后将之前tail的next指向新tail的节点。若tail为空或者CAS失败，enq兜底，以死循环的方式，若tail为空，说明不存在队列数据，CAS设置空NODE到head、tail中，然后CAS将当前node添加至tail节点，直到CAS成功设置到tail节点后返回（此时并没有判断之前tail的状态）。
private Node addWaiter(Node mode) {
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;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// CAS抢占队列尾节点失败或者不存在尾节点时
enq(node);
return node;
}
private Node enq(final Node node) {
// 死循环
for (;;) {
// 尾节点若为空，CAS设置新节点到head中(初始化队列）
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
// 首尾node都是新初始化的node节点
tail = head;
} else {
// 若队列已存在nocde，将尾节点设置为当前node 的头节点进行CAS
node.prev = t;
if (compareAndSetTail(t, node)) {
// 成功后，再将队列之前的尾节点的next指向新尾节点
// （由此可以看出，是先建立node尾节点指向之前队列节点，后续建立队列节点next指向新node节点）
t.next = node;
return t;
}
}
}
}
acquireQueued的shouldParkAfterFailedAcquire方法
当不是头节点或者获取锁失败时，设置node的前置节点的状态，当prev节点的状态>0，也就是取消状态时，node的prev属性会根据之前的prev节点数据一直往前找，直到找到非取消状态的node节点，然后，进行关联。这样当node插入队列时，即梳理去除掉了部分取消状态的node节点。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
但是node节点的状态是随时可能变更为取消状态的，很可能是node关联后，前置节点改为取消状态。这里先看下解锁时唤醒节点的流程。
release
当head节点不为空，且状态不为0时，说明h的next节点已经存在。通过unparkSuccessor去唤醒队列中的第一个节点。
情况一：若头节点的next为空，说明node刚刚CAS建立了prev节点，头节点还未来得及设置next，则从tail往前获取到头部第一个非取消状态的node信息，进行唤醒。
情况二：若头节点状态为取消状态，说明next节点已取消，则遍历队列从后往前得到头部第一个非取消状态的node信息，进行唤醒。
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 若节点next为空、若为取消状态，那么从tail进行队列的唤醒
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
// 从后往前遍历，获取得到非取消状态的node，进行唤醒
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
我们知道，当唤醒线程后，线程仍然会执行死循环，判断是否是头节点、CASstatus值成功后，标志着获取到锁返回。若头节点的状态为cancel，从后往前获取得到的非取消状态的node的prev并不是头节点，岂不是没有tryAcquire获取锁的资格，也就始终存在在队列中？
当进行第一次循环时，确实无法得到有效执行，当进入shouldParkAfterFailedAcquire()时，会判断队列中第一个获取状态的node节点的prev数据是否是取消状态，依次往前找到第一个非取消状态的节点，然后再次循环争抢锁。
注：因为node取消时，是改变自身node状态，依次，遍历到头节点时，便可以有效退出当前循环，执行获取锁的流程。
扩展cancelAcquire方法
线程因为中断、超时等，未成功获取到锁，流转到cancelAcquire方法。
node的线程设置为null，且根据node的prev往前找到第一个非取消状态的node节点(有效节点)，将当前node置为取消状态，注：这里可以看到，改变的是node本身的状态之前，而不是前置节点的状态，所以当从后往前遍历校验状态值时，头节点一定不是取消状态。
情况一：当node为尾节点时，CAS设置prev有效节点为tail节点，若成功，CAS将新的tail节点的next置为空，置空结果无需理会，失败了说明存在其他线程竞争设置到tail节点了，属于正常流程。
情况二：当node即不是尾节点，又不是头节点时，prev节点设置为休眠时，将node节点的next节点替换到prev节点的next中。
情况三：当node是头节点的next节点时，唤醒node
private void cancelAcquire(Node node) {
// Ignore if node doesn't exist
if (node == null)
return;
node.thread = null;
// Skip cancelled predecessors
// node的节点前置的node状态校验，若已取消，循环设置并判断之前node状态，直到找到非取消状态的node节点
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.
// 前置节点的next指向
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设置为取消状态
node.waitStatus = Node.CANCELLED;
// If we are the tail, remove ourselves.
// 若是尾节点，将前置节点的nextCAS设置为空（尾节点取消，将非取消状态的最近的前置节点CAS为尾节点）
if (node == tail && compareAndSetTail(node, pred)) {
// 失败，说明有其他线程加入到队列中，tail就应该是最新加入的线程
compareAndSetNext(pred, predNext, null);
} else {
// 非尾节点或者CAS尾节点失败
// If successor needs signal, try to set pred's next-link
// so it will get one. Otherwise wake it up to propagate.
int ws;
// 当前置节点不为头节点且状态为休眠，线程不为空时，将当前node的后置nodeCAS设置到pred节点上去
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 {
// 头节点，唤醒后续节点，因当前节点为1，所以会过滤唤醒，执行后续节点
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
