AbstractQueuedSynchronizer是java concurrent包的基础，JUC的底层实现就是靠AQS和volatile来实现的。每个java coder都必须了解的一块内容，自己也是看了忘，忘了又看，今天打算好好总结下，留着后面复习之用。
AQS采用了模板设计模式，我们在自定义锁的时候，只需要实现其几个简单的方法即可。AQS内部采用了一个用volatile修饰的state来表示的同步状态，以及用FIFO双向队列来给等待获取锁的线程排队。
AQS独占锁的大致执行流程：
- 获取锁的过程：
1、调用acquire尝试获取锁，获取成功就执行逻辑代码
2、如果获取锁资源失败的就把当前线程加入到同步队列中 去，并且挂起当前线程，等待锁资源释放唤醒线程
3、同步队列中的线程等待被唤醒重新获取锁资源，获取成功则继续执行逻辑代码，失败则继续挂起等待。 - 释放锁的过程：
1、当前线程调用release()方法释放锁，如果没有其他线程等待锁资源（即同步队列为空），则释放锁动作完成。
2、若同步队列不为空时，则唤醒同步队列头结点
下面进行源码的具体分析：
获取锁的方法acquire()源码：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这里是获取独占锁的逻辑，代码很短。
tryAcquire(arg)：是获取锁资源，由用户自己实现定义的接口。如果成功则整个方法结束。
addWaiter(Node.EXCLUSIVE)：以独占模式将当前线程添加到同步队列中，并且返回以改线程包装的节点Node
acquireQueued：同步队列中的线程以不间断的模式获取锁资源，也用在条件队列中调用（即Condition中）。
addWaiter(Node.EXCLUSIVE)源码分析：
static final class Node {
//共享模式
static final Node SHARED = new Node();
//独占模式
static final Node EXCLUSIVE = null;
//线程对应的节点已被取消
static final int CANCELLED = 1;
//暗示要通知后继节点
static final int SIGNAL = -1;
//等待状态，节点在等待队列中，节点中的线程在等待Condition，当其他线程对condition调用singnal()方法时，当前线程的节点从等待队列移到同步队列中，加入到同步状态的获取
static final int CONDITION = -2;
//共享状态，无条件将行为往下传播
static final int PROPAGATE = -3;
//节点状态
volatile int waitStatus;
//当前节点的前驱节点
volatile Node prev;
//当前节点的后继节点
volatile Node next;
//当前节点对应的线程
volatile Thread thread;
//链接在等待队列中的下一个等待节点
Node nextWaiter;
}
private Node addWaiter(Node mode) {
//以当前线程创建一个节点(独占锁是以独占模式创建节点，并且waitStatus为0)
Node node = new Node(Thread.currentThread(), mode);
//如果尾节点不为空时，进行节点的快速插入到尾节点
Node pred = tail;
if (pred != null) {
node.prev = pred;
//如果在这个时候没有其他线程插入到尾节点，那么就把当前节点插入到尾节点，否则快速插入失败，程序往下走。CAS操作
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
//上面节点快速插入尾节点失败的时候，重新在这里插入到尾节点
enq(node);
//返回节点
return node;
}
private Node enq(final Node node) {
//无限循环把节点加入到同步队列
for (;;) {
Node t = tail;
//如果当前尾节点为空，则初始化头节点和尾节点
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
//cas操作把当前节点加入到尾节点
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
之前一直没有搞懂这里为什么要new一个空的头结点，可以这样来理解：初始化队列的触发条件是当前已有线程占有了锁资源，当前空的头节点可以被认为是此时已经占有锁资源的节点。
enq(node)就是死循环来把节点加入到尾节点，因为存在并发获取锁资源的线程也在这个时候加入到同步队列中，cas操作不一定会成功，所以这里就采用死循环来不停地进行重试插入到尾节点。
下面是刚刚加入到同步队列中的节点开始不间断地获取锁资源，并且来看线程是否需要挂起或中断
不间断地获取锁资源
final boolean acquireQueued(final Node node, int arg) {
//获取锁资源的标记置为失败
boolean failed = true;
try {
//线程中断的标记置为false
boolean interrupted = false;
for (;;) {
//获取当前节点的前驱
final Node p = node.predecessor();
//如果当前节点的前驱节点为头节点，则去获取锁资源
if (p == head && tryAcquire(arg)) {
//获取锁资源成功则将当前节点设为头结点，这里不需要用cas操作，因为这里已成功获取到了锁资源后不需要靠率并发问题
setHead(node);
//将当前节点的前驱节点的next置为null，帮助GC
p.next = null; // help GC
//获取锁资源标记置为成功
failed = false;
//返回终端标记
return interrupted;
}
//检查在获取锁资源后是否需要挂起并挂起检查中断
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
//最后获取锁资源失败的时候取消获取，这一般使我们的tryAcquire的实现出现了异常
if (failed)
//这里我暂且没有看懂等我后续梳理
cancelAcquire(node);
}
}
//判断当前节点是否需要挂起
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//当前节点的前驱节点的状态
int ws = pred.waitStatus;
//如果当前节点的前驱节点状态是-1，那么当前节点可以安心的挂起，等待前驱节点释放锁资源的时候进行唤醒
if (ws == Node.SIGNAL)
return true;
//当前节点的前驱节点为取消状态时，那么往前追溯到一个不是取消的节点，将它作为当前节点node的前驱节点，其实这个时候也删除了同步队列中状态为取消的节点
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
//注，由于头结点head是通过new Node()创建，它的waitStatus为0,因此这里不会出现空指针问题，也就是说最多就是找到头节点上面的循环就退出了
pred.next = node;
} else {
//这里状态只能是0或-3(因为状态为-2的节点在等待队列中)，那么久把当前节点的前驱节点置为-1，让外层for循环的下一次循环再进入到这个方法，重新进行判断是否需要挂起
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
//挂起当前线程，并且返回当前线程的中断标志位
private final boolean parkAndCheckInterrupt() {
//挂起当前线程
LockSupport.park(this);
//被唤醒之后，返回当前线程的中断标志位
return Thread.interrupted();
}
这个不间断获取同步状态的代码流程是：
- 声明两个标记变量：failed(获取同步状态的标记)和interrupted(当前线程是否中断标记)
- 死循环进行获取同步状态，其实这里只有前驱节点是头节点的节点才会去尝试获取同步状态，其他节点进行了挂起，不去尝试获取同步状态，这样节约资源，不去浪费资源。获取到了同步状态时，把当前节点设置为头节点(头节点都是获取到了同步状态的节点)，并且把前驱节点移出同步队列，因为当前节点能获取到同步状态是因为前驱节点释放了同步状态，并且唤醒了当前节点，因此当前节点才能获取到同步状态。
- 判断当前节点是否需要挂起，当前节点的前驱节点状态是-1的时候就会被挂起，安心等前驱节点释放同步状态的时候唤醒。并且把状态为1(线程被取消或中断的节点)的节点移出同步队列。如果当前节点的前驱节点为0或-3就把前驱节点的状态设置为-1，最终线程挂起，返回中断标致。
下面来看下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
}
}
最后来看下释放同步状态的源码：
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;
}
//唤醒节点，这里传过来的参数是头节点
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//把当前节点的状态设置为0，表示唤醒动作已开始，提高并发的性能
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
//这里的s是释放同步状态节点的后继节点
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);
}
在头节点释放同步状态的时候，唤醒其后继节点。