1. 概念

设计初衷：该类利用 状态+队列 实现了一个同步器，更多的是提供一些模板方法（子类必须重写，不然会抛错）。
设计功能：独占、共享模式

2. 两个核心，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. 核心获取同步锁流程

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); // 清除中断标志

4. 获取同步锁流程图