AQS-ReentrantLock（加锁）源码浅析
1、ReentrantLock
ReentrantLock实现主要依赖extends AbstractQueuedSynchronizer，在源码里面xxxSync extends Sync实现lock 方法，而Sync 父类即是AbstractQueuedSynchronizer。
实现方法如下：通过acquire(1)；方法内部实现 AQS。
final void lock() {
acquire(1);
}
2、acquire 方法
（1）tryAcquire(arg)，尝试获取资源，是否获取成功获取成功，直接放行继续执行。否则执行acquireQueued。
public final void acquire(int arg) {
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
3、acquireQueued方法
（1）将尝试获取资源失败的 线程，创建链表节点进入阻塞队列。
（2）addWaiter，添加并创建节点，Node.EXCLUSIVE 默认独占模式，NODE.SHARED 共享模式。
private Node addWaiter(Node mode) {
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;
}}
//如果尾部节点 是 null，enq进行初始化节点，并cas 将当前创建新节点设置到链表尾部节点。
enq(node);
//返回当前节点
return node;
}
（3）回到acquireQueued方法
final boolean acquireQueued(final Node node, int arg) {
//尝试是否失败
boolean failed = true;
try {
//是否被打断
boolean interrupted = false;
//注意这里将不断循环重试如下操作
for (;;) {
//获取当前节点的前节点
final Node p = node.predecessor();
//如果当前节点的 前节点==head节点，那么当前节点即可尝试去获取资源，如果获取资源成功，表示当前节点的前节点已经无效，将当前节点设置为 head节点，将前节点置为null帮助GC回收。返回尝试获取状态，以及是否被打断。
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果当前节点不是 head节点 or 尝试获取资源失败。
if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
interrupted = true;
}} finally {
//如果响应中断，异常表示当前节点，被取消
if (failed)
cancelAcquire(node);
}}
（4）shouldParkAfterFailedAcquire，循环检测是否能够进行unpark阻塞状态，等待许可。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//获取前节点的 节点状态，（SIGNAL:指示后续线程，需要许可解锁阻塞）
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
//前节点 状态 ==SIGNAL 返回true 由parkAndCheckInterrupt方法进行 park阻塞，暂停循环。
return true;
if (ws > 0) {
//前节点状态>0 （CANCELLED：表示线程已取消的waitStatus值），可能由于打断 or timeout结束了当前节点。
do {
//出现如上情况，当前节点会，不断循环往上查找到状态不是>0的节点，并把自己的前驱指向该节点。
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果前节点状态 ！>0 and ！= Node.SIGNAL，表示当前节点处于其他两种状态（CONDITION、PROPAGATE），将通过cas将前节点状态设置为 Node.SIGNAL。
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;}
5、当从shouldParkAfterFailedAcquire方法获取park许可，接下来通过parkAndCheckInterrupt调用park进行阻塞，并返回当前线程是否被打断。
private final boolean parkAndCheckInterrupt() {
//阻塞等待 unpark许可，终止 for循环。
LockSupport.park(this);
return Thread.interrupted();
}
6、cancelAcquire 取消当前节点在链表。
private void cancelAcquire(Node node) {
if (node == null)
return;
node.thread = null;
Node pred = node.prev;
while (pred.waitStatus > 0)
node.prev = pred = pred.prev;
Node predNext = pred.next;
node.waitStatus = Node.CANCELLED;
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
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 }}
