Java - AbstractQueuedSynchronizer

AQS简介

AQS全称AbstractQueuedSynchronizer，抽象队列同步器，是一个实现同步组件的基础框架。AQS使用一个int类型的成员变量state维护同步状态，通过内置的同步队列（CLH锁、FIFO）完成线程的排队工作，底层主要是通过CAS操作和volatile特性实现。

它主要包含两种模式：独占模式（例如ReentrantLock）和共享模式（例如CountDownLatch）。关键方法包括acquire和release，用于独占模式下的获取和释放操作，以及acquireShared和releaseShared，用于共享模式下的操作。

它简化了同步组件的实现方式，屏蔽了同步状态的管理、线程的排队等待与唤醒等底层操作。我们只需要通过继承实现AQS中的抽象方法，即可实现不同同步语义的同步组件。例如ReentrantLock这种独占式同步组件，核心逻辑仅重写了tryAcquire和tryRelease等少数方法，就实现了可重入独占式锁的功能。

AQS通过继承来扩展其功能，子类通过继承AQS实现抽象方法来管理同步状态，同步组件则通过聚合子类的方法来实现自己的同步特性，独占式或共享式。

使用AQS实现一个自定义排他锁

继承AQS：
创建一个新的类，继承AbstractQueuedSynchronizer。

实现核心方法：
实现tryAcquire和tryRelease方法（用于独占模式），或实现tryAcquireShared和tryReleaseShared方法（用于共享模式）。

内部类Sync：
通常创建一个内部静态类Sync，扩展AQS并实现上述方法。

对外方法：
在外部类中，提供获取和释放的方法，内部调用AQS的方法acquire、release、acquireShared和releaseShared。

import java.util.concurrent.locks.AbstractQueuedSynchronizer;public class SimpleLock {private final Sync sync = new Sync();private static class Sync extends AbstractQueuedSynchronizer {@Overrideprotected boolean tryAcquire(int arg) {if (compareAndSetState(0, 1)) {setExclusiveOwnerThread(Thread.currentThread());return true;}return false;}@Overrideprotected boolean tryRelease(int arg) {if (getState() == 0) throw new IllegalMonitorStateException();setExclusiveOwnerThread(null);setState(0);return true;}@Overrideprotected boolean isHeldExclusively() {return getExclusiveOwnerThread() == Thread.currentThread();}}public void lock() {sync.acquire(1);}public void unlock() {sync.release(1);}public boolean isLocked() {return sync.isHeldExclusively();}
}

使用AQS实现一个自定义共享锁

import java.util.concurrent.locks.AbstractQueuedSynchronizer;public class SimpleSemaphore {private final Sync sync;public SimpleSemaphore(int permits) {sync = new Sync(permits);}private static class Sync extends AbstractQueuedSynchronizer {Sync(int permits) {setState(permits);}@Overrideprotected int tryAcquireShared(int acquires) {for (;;) {int available = getState();int remaining = available - acquires;if (remaining < 0 || compareAndSetState(available, remaining)) {return remaining;}}}@Overrideprotected boolean tryReleaseShared(int releases) {for (;;) {int current = getState();int next = current + releases;if (compareAndSetState(current, next)) {return true;}}}}public void acquire() throws InterruptedException {sync.acquireSharedInterruptibly(1);}public void release() {sync.releaseShared(1);}
}

同步队列和条件队列的区别

同步队列（synchronization queue）和条件队列（condition queue）是AbstractQueuedSynchronizer（AQS）中的两个不同的队列，它们有不同的用途和工作机制。

同步队列

用途：管理所有等待获取锁或同步状态的线程。
触发条件：当线程尝试获取锁或同步状态失败时进入队列。
结构：双向链表。
作用：维护线程的顺序，确保公平竞争。
唤醒机制：当锁释放或同步状态改变时，唤醒队列中的下一个线程。

条件队列

用途：管理等待特定条件的线程（通过ConditionObject）。
触发条件：当线程调用await()方法时进入队列，并释放当前持有的锁。
结构：单向链表。
作用：等待特定条件的满足，如某个状态的变化。
唤醒机制：当条件满足时（通过signal()或signalAll()），线程从条件队列移动到同步队列，等待重新获取锁。

为什么await方法一定要加锁才能调用

我理解条件队列现在的实现是在await方法先完全释放锁，再进入休眠状态等待唤醒，被唤醒后重新尝试加锁。先完全释放锁，是为了防止当前线程持有锁时错误休眠，若当前线程持有锁进入休眠状态，即使当前线程被唤醒，也是尝试加锁而不是解锁，那么其他线程永远无法拿到锁。因此先完全解锁再休眠，被唤醒后重新尝试加锁，应该是出于防止锁饥饿与死锁的考虑。

AQS独占式加锁（以ReentrantLock加锁为例）

加锁流程

~~加锁源码分析~~

解锁流程

~~解锁源码分析~~

CLH锁（同步队列的原型）

CLH锁是对自旋锁的一种改良，自旋锁只适合竞争不激烈，加锁时间短的场景，原因是自旋锁有2个问题，第一，存在锁饥饿问题，可能会出现某个线程一直拿不到锁的情况；第二，锁状态中心化，激烈竞争时会导致CPU的高速缓存频繁失效，导致性能降低。

CLH队列锁有效地解决了以上2个问题，首先，CLH锁通过增加队列进行排队，确保所有线程都有机会拿到锁；第二，CLH锁的每个线程监视的都是上一个节点的锁状态，因此锁状态是去中心化的，不会导致CPU高速缓存频繁失效。

CLH锁实现源码

import java.util.concurrent.atomic.AtomicReference;public class CLH {private final ThreadLocal<Node> node = ThreadLocal.withInitial(Node::new);private final AtomicReference<Node> tail = new AtomicReference<>(new Node());private static class Node {// ①锁定状态必须用volatile修饰以确保内存可见性private volatile boolean locked;}public void lock() {Node node = this.node.get();node.locked = true;Node pre = this.tail.getAndSet(node);while (pre.locked) ;}public void unlock() {Node node = this.node.get();node.locked = false;// ②重置当前线程对应的Node节点避免死锁this.node.set(new Node());}
}

原理分析

观察代码可以发现，CLH没有前驱或后继指针，因为CLH锁是一种隐式队列，入队只需要添加新的tail节点，出队只需要修改头部状态。注释①处必须用volatile修饰，以确保内存可见性与代码有序性。注释②处必须重置线程Node，否则当一个线程重复加锁时，就有可能死锁，死锁原因可以看这篇文章的解锁分析部分。

CLH锁的优点是性能优异、实现简单、加锁公平、扩展性强。但缺点是有自旋操作，长时间加锁会浪费CPU性能，再就是功能单一，不支持复杂的功能。

针对以上两个缺点，AQS都做了改进。针对第一个缺点，将自旋改为了线程阻塞等待；针对第二个缺点，AQS做了很多改造和扩展，例如增加了每个节点的状态waitStatus、显式维护了前驱和后继节点等等，基于这些扩展，AQS实现了独占锁、共享锁、线程排队、状态传播等复杂功能。