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 {
        @Override
        protected boolean tryAcquire(int arg) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        @Override
        protected boolean tryRelease(int arg) {
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        @Override
        protected 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);
        }

        @Override
        protected int tryAcquireShared(int acquires) {
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 || compareAndSetState(available, remaining)) {
                    return remaining;
                }
            }
        }

        @Override
        protected 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实现了独占锁、共享锁、线程排队、状态传播等复杂功能。

参考链接

从ReentrantLock的实现看AQS的原理及应用 - 美团技术团队

AQS 详解 | JavaGuide

AQS的前菜—详解CLH队列锁_clh锁-CSDN博客

Java AQS 核心数据结构-CLH 锁

JUC锁:核心类AQS源码详解 - 拿了桔子跑-范德依彪 - 博客园