概念
设计初衷：该类利用 状态+队列 实现了一个同步器，更多的是提供一些模板方法（子类必须重写，不然会抛错）。
设计功能：独占、共享模式两个核心，state、Queue
2.1 state
setState、compareAndSetState都是用于修改同步状态。看类名其实就知道一个是线程不安全的（setState），一个是使用了乐观锁来保证线程安全（compareAndSetState）。
使用场景
setState：应用于释放资源的线程，因为同一时间只有一个使用这个线程不安全的方法去修改state的值，所以不会发生并发安全问题
compareAndSetState：应用于尝试获取同步器的资源，由于同一时间可能存在多个资源竞争锁，所以需要使用unsfte类的cas保证线程安全
private volatile int state; // 同步状态值，0：空闲，>0：有多少个线程在同步队列中等待
protected final int getState() { // 获取同步状态
return state;
}
protected final void setState(int newState) { // 修改同步状态
state = newState;
}
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update); // 通过unsafe类的cas修改同步状态
}2.2 Queue
底层：带头、尾节点的双向链表
private transient volatile Node head; // 头节点
private transient volatile Node tail; // 尾节点
static final class Node {
volatile Node prev; // 前一个节点
volatile Node next; // 后一个节点
}核心获取同步锁流程
3.1 acquire
public final void acquire(int arg) {
// 尝试获取资源失败，且成功加入同步队列，则阻塞线程
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt(); // 获取不到资源或者加入队列失败，那就中断该线程
}3.2 tryAcquire
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException(); // 模板方法，让子类实现
}3.3 addWaiter
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)) { // 因为同时间内有多个线程进入队列，所以使用cas置换尾节点
pred.next = node; // 原尾节点的下一个指针指向新插入的节点
return node;
}
}
enq(node); // 队列为空，需要初始化队列插入
return node;
}3.4 enq
private Node enq(final Node node) {
for (;;) { // 自旋，创建到成功为止
Node t = tail;
if (t == null) { // 还是并发安全问题，保守判断一下，是不是有人抢先一步
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t; // 插入节点指向尾巴
if (compareAndSetTail(t, node)) { // 交换尾节点
t.next = node; // 上一个节点指向当前插入节点
return t;
}
}
}
}3.5 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; // GC掉，因为当前节点获取到资源，说明上一个节点已经执行完毕业务了
failed = false; // 设置成功
return interrupted; // 不阻塞
}
if (shouldParkAfterFailedAcquire(p, node) && // 没有获取到资源，把线程挂起，别浪费资源
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node); // 获取到资源，取消尝试获取资源
}
}3.6 shouldParkAfterFailedAcquire
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus; // 上一个节点的wait状态
if (ws == Node.SIGNAL) // 上一个节点是SIGNAL状态，说明可以阻塞，回去等通知就行
return true;
if (ws > 0) { // 如果大于0，说明是CANCELLED状态，那就把前面那些废物节点扔掉
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0); // 扔啊扔，扔到前一个节点不是废物节点
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL); // 小于0，说明前面有节点，更改成SIGNAL状态
}
return false;
}3.6.1 waitStatus
static final int CANCELLED = 1; // 废弃状态，有些加入了又不想等，就玩儿
static final int SIGNAL = -1; // 等待激活下一个节点的状态，下一个节点肯定是被Condiction.await()
static final int CONDITION = -2; // 条件状态，中间节点
static final int PROPAGATE = -3; // 共享模式下的节点状态3.7 parkAndCheckInterrupt
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this); // 挂起当前线程
return Thread.interrupted();
}3.7.1 interrupted
public static boolean interrupted() {
return currentThread().isInterrupted(true); // 获取当前线程是否为中断状态
}
private native boolean isInterrupted(boolean ClearInterrupted); // 清除中断标志获取同步锁流程图
