AbstractQueuedSynchronizer底层已经通过AQS队列实现了线程的阻塞和唤醒机制
分别对应下面函数，且均为final修饰，即子类不可修改
独占锁：acquire release
共享锁：acquireShared releaseShared

子类子需要继承AbstractQueuedSynchronizer并重写tryAcquire tryRelease tryAcquireShared tryReleaseShared等函数

以可重入锁的非公平锁为例

获取锁
acqurie函数

// AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))// 如果线程被中断了逻辑来到这，完成一次真正的打断效果selfInterrupt();
}

tryAcquire 尝试获取锁失败时, 会调用 addWaiter 将当前线程封装成node入队，acquireQueued 阻塞当前线程，
acquireQueued 返回 true 表示阻塞过程中线程被中断唤醒过，false 表示未被中断过。

tryAcquire ：由子类自定义实现（可以实现公平锁和非公平锁）
以ReentrantLock非公平锁为例：

// ReentrantLock.NonfairSync#tryAcquire
protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);
}
// 抢占成功返回 true，抢占失败返回 false
final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();// state 值int c = getState();// 条件成立说明当前处于【无锁状态】if (c == 0) {//如果还没有获得锁，尝试用cas获得，这里体现非公平性: 不去检查 AQS 队列是否有阻塞线程直接获取锁        if (compareAndSetState(0, acquires)) {// 获取锁成功设置当前线程为独占锁线程。setExclusiveOwnerThread(current);return true;}    } // 这部分是重入锁的原理    // 如果已经有线程获得了锁, 独占锁线程还是当前线程, 表示【发生了锁重入】else if (current == getExclusiveOwnerThread()) {// 更新锁重入的值int nextc = c + acquires;// 越界判断，当重入的深度很深时，会导致 nextc < 0，int值达到最大之后再 + 1 变负数if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");// 更新 state 的值，这里不使用 cas 是因为当前线程正在持有锁，所以这里的操作相当于在一个管程内setState(nextc);return true;}// 获取失败return false;
}

正是这个方法体现了非公平锁，在nonfairTryAcquire如果发现state=0，无锁的情况，它会忽略队列中等待的线程，优先获取一次锁，相当于"插队"。

addWaiter将当前线程关联到一个 Node 对象上, 并加入阻塞队列

// AbstractQueuedSynchronizer#addWaiter，返回当前线程的 node 节点
private Node addWaiter(Node mode) {// 将当前线程关联到一个 Node 对象上, 模式为独占模式   Node node = new Node(Thread.currentThread(), mode);Node pred = tail;// 快速入队，如果 tail 不为 null，说明存在阻塞队列if (pred != null) {// 将当前节点的前驱节点指向 尾节点node.prev = pred;// 通过 cas 将 Node 对象加入 AQS 队列，成为尾节点，【尾插法】if (compareAndSetTail(pred, node)) {pred.next = node;// 双向链表return node;}}// 初始时队列为空，或者 CAS 失败进入这里enq(node);return node;
}

enq函数：初始时队列为空，或者 CAS 失败后调用该方法自旋入队

// AbstractQueuedSynchronizer#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  = null，并且这里已经 CAS 结束，线程并不是安全的】t.next = node;return t;	// 返回当前 node 的前驱节点}}}
}

head结点不参与锁竞争，只负责唤醒后续结点，初始状态waitStatus 为0，后续有节点加入会被修改为-1，即signal。
waitStatus 状态：0 为默认正常状态， -1状态表示它肩负唤醒下一个节点的线程。

acquireQueued 会在一个自旋中不断尝试获得锁，失败且找到能唤醒自己的前驱结点后进入 park 阻塞等待被唤醒。

如果当前线程是在 head 节点后，也就是第二个节点，又会直接多一次机会 tryAcquire 尝试获取锁，如果还是被占用，失败再次进入park等待被唤醒。

线程结点

inal boolean acquireQueued(final Node node, int arg) {// true 表示当前线程抢占锁失败，false 表示成功boolean failed = true;try {// 中断标记，表示当前线程是否被中断boolean interrupted = false;for (;;) {// 获得当前线程节点的前驱节点final Node p = node.predecessor();// 前驱节点是 head, FIFO 队列的特性表示轮到当前线程可以去获取锁if (p == head && tryAcquire(arg)) {// 获取成功, 设置当前线程自己的 node 为 headsetHead(node);p.next = null; // help GC// 表示抢占锁成功failed = false;// 返回当前线程是否被中断return interrupted;}// 判断是否应当 park，返回 false 后需要新一轮的循环，返回 true 进入条件二阻塞线程if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())// 条件二返回结果是当前线程是否被打断，没有被打断返回 false 不进入这里的逻辑// 【就算被打断了，也会继续循环，并不会返回】interrupted = true;}} finally {// 如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待。if (failed)cancelAcquire(node);}
}

cancelAcquire
如果等待过程中没有成功获取资源（如timeout，或者可中断的情况下被中断了），那么取消结点在队列中的等待。获取当前节点的前驱节点，如果前驱节点的状态是CANCELLED，那就一直往前遍历，找到第一个waitStatus <= 0的节点，将找到的Pred节点和当前Node关联，将当前Node设置为CANCELLED

private void cancelAcquire(Node node) {// 将无效节点过滤if (node == null)return;// 设置该节点不关联任何线程，也就是虚节点node.thread = null;Node pred = node.prev;// 通过前驱节点，跳过取消状态的nodewhile (pred.waitStatus > 0)node.prev = pred = pred.prev;// 获取过滤后的前驱节点的后继节点Node predNext = pred.next;// 把当前node的状态设置为CANCELLEDnode.waitStatus = Node.CANCELLED;// 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点// 更新失败的话，则进入else，如果更新成功，将tail的后继节点设置为nullif (node == tail && compareAndSetTail(node, pred)) {compareAndSetNext(pred, predNext, null);} else {int ws;// 如果当前节点不是head的后继节点，1:判断当前节点前驱节点的是否为SIGNAL，2:如果不是，则把前驱节点设置为SINGAL看是否成功// 如果1和2中有一个为true，再判断当前节点的线程是否为null// 如果上述条件都满足，把当前节点的前驱节点的后继指针指向当前节点的后继节点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 {// 如果当前节点是head的后继节点，或者上述条件不满足，那就唤醒当前节点的后继节点unparkSuccessor(node);}node.next = node; // help GC}
}

shouldParkAfterFailedAcquire
寻找状态值为-1的前驱节点（能唤醒自己的前驱结点）
在进入park阻塞前，node结点要寻找能唤醒它的前驱结点，即waitStatus = -1的结点。

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;// 表示前置节点是个可以唤醒当前节点的节点，返回 trueif (ws == Node.SIGNAL)return true;// 前置节点的状态处于取消状态，需要【删除前面所有取消的节点】, 返回到外层循环重试if (ws > 0) {do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);// 获取到非取消的节点，连接上当前节点pred.next = node;// 默认情况下 node 的 waitStatus 是 0，进入这里的逻辑} else {// 【设置上一个节点状态为 Node.SIGNAL】，返回外层循环重试compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}// 返回不应该 park，再次尝试一次return false;
}

shouldParkAfterFailedAcquire发现前驱节点等待状态是-1， 返回true,表示需要阻塞。
shouldParkAfterFailedAcquire发现前驱节点等待状态大于0，说明是无效节点，会进行清理。
shouldParkAfterFailedAcquire发现前驱节点等待状态等于0，将前驱 node 的 waitStatus 改为 -1，返回 false。

private final boolean parkAndCheckInterrupt() {// 阻塞当前线程，如果打断标记已经是 true, 则 park 会失效LockSupport.park(this);// 判断当前线程是否被打断，清除打断标记return Thread.interrupted();
}

acquireQueued通过不断自旋尝试获取锁，即不断执行shouldParkAfterFailedAcquire，最终找到等待状态为-1的前驱节点，进行阻塞当前线程。parkAndCheckInterrupt通过调用LockSupport.park方法进行阻塞。

锁释放原理

AbstractQueuedSynchronizer release函数
tryRelease(arg)释放锁成功则唤醒AQS队列中的一个线程

// AbstractQueuedSynchronizer#release
public final boolean release(int arg) {// 尝试释放锁，tryRelease 返回 true 表示当前线程已经【完全释放锁，重入的释放了】if (tryRelease(arg)) {// 队列头节点Node h = head;// 头节点什么时候是空？没有发生锁竞争，没有竞争线程创建哑元节点// 条件成立说明阻塞队列有等待线程，需要唤醒 head 节点后面的线程if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}    return false;
}

tryRelease需要子类自己实现：设置 exclusiveOwnerThread 为 null，state = 0
可重入锁，只有 state 减为 0, 才完全释放锁成功

// ReentrantLock.Sync#tryRelease
protected final boolean tryRelease(int releases) {// 减去释放的值，可能重入int c = getState() - releases;// 如果当前线程不是持有锁的线程直接报错if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();// 是否已经完全释放锁boolean free = false;// 支持锁重入, 只有 state 减为 0, 才完全释放锁成功if (c == 0) {free = true;setExclusiveOwnerThread(null);}// 当前线程就是持有锁线程，所以可以直接更新锁，不需要使用 CASsetState(c);return free;
}

释放成功后唤醒AQS队列阻塞的线程，参数为head结点

private void unparkSuccessor(Node node) {// 当前节点的状态int ws = node.waitStatus;    if (ws < 0)        // 【尝试重置状态为 0】，因为当前节点要完成对后续节点的唤醒任务了，不需要 -1 了compareAndSetWaitStatus(node, ws, 0);    // 找到需要 unpark 的节点，当前节点的下一个    Node s = node.next;    // 已取消的节点不能唤醒，需要找到距离头节点最近的非取消的节点if (s == null || s.waitStatus > 0) {s = null;// AQS 队列【从后至前】找需要 unpark 的节点，直到 t == 当前的 node 为止，找不到就不唤醒了for (Node t = tail; t != null && t != node; t = t.prev)// 说明当前线程状态需要被唤醒if (t.waitStatus <= 0)// 置换引用s = t;}// 【找到合适的可以被唤醒的 node，则唤醒线程】if (s != null)LockSupport.unpark(s.thread);
}

为什么这里查找唤醒的节点是从后往前，而不是从前往后呢？

从后向前的唤醒的原因：enq 方法中，节点是尾插法，首先赋值的是尾节点的前驱节点，此时前驱节点的 next 并没有指向尾节点，从前遍历会丢失尾节点。

被唤醒的线程Thread-1会从 park 位置开始执行acquireQueued的自旋获取锁操作。
acquireQueued自旋获取锁部分代码

for (;;) {// 获得当前线程节点的前驱节点final Node p = node.predecessor();// 前驱节点是 head, FIFO 队列的特性表示轮到当前线程可以去获取锁if (p == head && tryAcquire(arg)) {// 获取成功, 设置当前线程自己的 node 为 headsetHead(node);p.next = null; // help GC// 表示抢占锁成功failed = false;// 返回当前线程是否被中断return interrupted;}

• 如果Thread-1加锁成功（没有竞争），设置exclusiveOwnerThread为Thread-1， state=1。
  head 指向刚刚成功获取锁线程所在的 Node，将原本的head清空等待被gc。
• 另一种可能，突然来了Thread-2来竞争，体现非公平锁。如果Thread-2获取锁成功，Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞。

非公平锁部分代码

// c为state
if (c == 0) {//如果还没有获得锁，尝试用cas获得，这里体现非公平性: 不去检查 AQS 队列是否有阻塞线程直接获取锁        if (compareAndSetState(0, acquires)) {// 获取锁成功设置当前线程为独占锁线程。setExclusiveOwnerThread(current);return true;}    }