AQS入门理解

一、什么是AQS

1. AQS的定义

AQS 的全称为 AbstractQueuedSynchronizer ,中文译为抽象队列式同步器。这个类在 java.util.concurrent.locks 包下面。这个抽象类对于JUC并发包非常重要,JUC包中的 ReentrantLock,Semaphore,ReentrantReadWriteLock,CountDownLatch 等等几乎所有的类都是基于AQS实现的。

2. AQS的原理/思想

如果被请求的共享资源空闲,则将当前请求资源的线程设置为有效的工作线程,并将共享资源设置为锁定状态,如果被请求的共享资源被占用,那么就需要一套线程阻塞等待以及被唤醒时锁分配的机制,这个机制AQS是用CLH队列锁实现的,即将暂时获取不到锁的线程加入到队列中。

队列:AQS其实就是基于 CLH队列 产生的,这个队列是一个双向队列,不存在队列示例,仅存在节点之间的关系。用 volatile 关键字来修饰其中的变量 state,线程利用 CAS 去改变这个值,改变成功则表示获取成功,否则就是获取失败,进入等待队列等待被唤醒。

tips:AQS是自旋锁,等待唤醒的时候会不断自旋尝试获取锁,直到锁被获取或被其他线程获取

AQS的实现方式如下:

图片

AQS使用 private volatile int state 表示同步状态。通过内置的FIFO队列完成线程的排队。使用CAS对state进行修改。。

二、节点

第一节里我们提到 —— AQS 是基于 CLH 队列产生的,这个队列是一个虚拟的双向队列。这一节我们来看看这个队列里的节点。

在 AbstractQueuedSynchronizer 源码中,作者编写了 等待队列节点类,并赋予了类的解释:

等待队列是“CLH”(Craig、Landin和Hagersten)锁队列的变体。CLH锁通常用于旋转锁。相反,我们使用它们来阻止同步器,但使用相同的基本策略,即在其节点的前一个线程中保存一些关于该线程的控制信息。每个节点中的“状态”字段跟踪线程是否应该阻塞。当一个节点的前一个节点释放时,它会收到信号。队列的每个节点都充当一个特定的通知样式监视器,其中包含一个等待线程。

机器翻译读起来怪怪的,那就直接看这个类是什么样子吧:

static final class Node {
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;
    	// 队列中节点状态值 也就是 waitStatus
        static final int CANCELLED =  1;
        static final int SIGNAL    = -1;
        static final int CONDITION = -2;
        static final int PROPAGATE = -3;

    	// 队列中节点状态
        volatile int waitStatus;
    	// 前驱、后继
        volatile Node prev;
        volatile Node next;
    
        volatile Thread thread;

        Node nextWaiter;

        final boolean isShared() {
            return nextWaiter == SHARED;
        }
        
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        Node() {    // Used to establish initial head or SHARED marker
        }

        Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

以及最重要的成员:

private volatile int state;

线程获取或释放锁的本质是去修改AQS里的 state。比如说,我们创建一个ReentrantLock的实例,此时该锁实例内部的state为0,表征它还没有被任何线程所持有。当多个线程同时调用它的lock()方法获取锁时,它们的本质操作其实就是将该锁实例的state值由0修改为1,第1个抢到这个操作执行的线程就成功获取了锁,后续执行操作的线程就会看到state值已经为1了,即表明该锁已经被其他线程获取,它们抢占锁失败了。这些抢占锁失败的线程会被AQS放入到CHL队列里面去维护起来。

三、实现AQS

AQS支持线程抢占两种锁——独占锁和共享锁:

独占锁:同一个时刻只能被一个线程占有,如ReentrantLock,ReentrantWriteLock等,它又可分为:
公平锁:按照线程在队列中的排队顺序,先到者先拿到锁
非公平锁:当线程要获取锁时,无视队列顺序直接去抢锁,谁抢到就是谁的
共享锁:同一时间点可以被多个线程同时占有,如ReentrantReadLock,Semaphore等
AQS的所有子类中,要么使用了它的独占锁,要么使用了它的共享锁,不会同时使用它的两个锁。

在 AQS 的源码里,作者是这么说的:

要将此类用作同步器的基础,请通过使用getState、setState和/或compareAndSetState检查和/或修改同步状态,重新定义以下方法(如适用):
tryAcquire
tryRelease
tryAcquireShared
tryReleaseShared
isHeldExclusively

//独占锁的获取锁与释放锁
//返回值表示获取锁是否成功
protected boolean tryAcquire(int arg){}
//返回值表示释放锁是否成功
protected boolean tryRelease(int arg){}

//共享锁的获取锁与释放锁
//返回值表示获得锁后还剩余的许可数量
protected int tryAcquireShared(int arg){}
//返回值表示释放锁是否成功
protected boolean tryReleaseShared(int arg){}

//调用该方法的线程是否持有独占锁,一般用到了condition的时候才需要实现此方法
protected boolean isHeldExclusively(){}

这些方法是子类需要实现的,可以选择实现其中的一部分。根据实现方式的不同,可以分为两种:独占锁和共享锁

独占锁需要实现的是 tryAcquire(int)、tryRelease(int)
共享锁需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)

以ReentrantLock为例:state初始化为0,表示未锁定状态,A线程lock()时,会调用tryAcquire()独占锁并将state+1.之后其他线程再想tryAcquire的时候就会失败,直到A线程unlock()到state=0为止,其他线程才有机会获取该锁A释放锁之前,自己也是可以重复获取此锁(state累加),这就是可重入的概念
注意:获取多少次锁就要释放多少次锁,保证state是能回到零态的。

以CountDownLatch为例,任务分N个子线程去执行,state就初始化为N,N个线程并行执行,每个线程执行完之后countDown()一次,state就会CAS减一。当N子线程全部执行完毕,state=0,会unpark()主调用线程,主调用线程就会从await()函数返回,继续之后的动作。

1. ReentrantLock

ReentrantLock 默认采用非公平锁,因为考虑获得更好的性能,通过 boolean 来决定是否用公平锁(传入 true 用公平锁)。

private final Sync sync;
public ReentrantLock() {
        sync = new NonfairSync();
    }
public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
// 非公平锁的实现
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    final void lock() {
        // 尝试直接获取锁
        if (compareAndSetState(0, 1))
            // 获取到了直接返回
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

// nonfairTryAcquire 方法
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 非公平锁不判断阻塞队列的状态
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}
// 公平锁的实现
static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            // 	
            int c = getState();
            if (c == 0) {
                // 公平锁先判断阻塞队列的状态
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

公平锁和非公平锁的不同:

  1. 非公平锁在调用 lock 之后,会直接调用 CAS 进行抢锁,如果此时锁未被占用,则直接获得锁并返回。
  2. 非公平锁 CAS 抢锁失败后,和公平锁一样都会通过 acquire(1) 进入到 tryAcquire 方法。在这个方法中,如果发现锁被释放了,也就是 state = 0,非公平锁会直接尝试 CAS 抢锁,公平锁会判断是否有线程处于等待状态,如果有则自行排到队列后等待唤醒。

2. CountDownLatch

CountDownLatch允许一个或者多个线程去等待其他线程完成操作。需要实现的是 tryAcquireShared(int)、tryReleaseShared(int)

private static final class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 4982264981922014374L;

    Sync(int count) {
        setState(count);
    }

    int getCount() {
        return getState();
    }

    protected int tryAcquireShared(int acquires) {
        return (getState() == 0) ? 1 : -1;
    }

    protected boolean tryReleaseShared(int releases) {
        // Decrement count; signal when transition to zero
        for (;;) {
            int c = getState();
            if (c == 0)
                return false;
            int nextc = c-1;
            if (compareAndSetState(c, nextc))
                return nextc == 0;
        }
    }
}

3. Mutex

本质上都是实现 tryAcquire(int)、tryRelease(int) 或者 tryAcquireShared(int)、tryReleaseShared(int)

class Mutex implements Lock, java.io.Serializable {

        // Our internal helper class
        private static class Sync extends AbstractQueuedSynchronizer {
            // Reports whether in locked state
            protected boolean isHeldExclusively() {
                return getState() == 1;
            }
            // Acquires the lock if state is zero
            public boolean tryAcquire(int acquires) {
                assert acquires == 1; // Otherwise unused
                if (compareAndSetState(0, 1)) {
                    setExclusiveOwnerThread(Thread.currentThread());
                    return true;
                }
                return false;
            }
            // Releases the lock by setting state to zero
            protected boolean tryRelease(int releases) {
                assert releases == 1; // Otherwise unused
                if (getState() == 0) throw new IllegalMonitorStateException();
                setExclusiveOwnerThread(null);
                setState(0);
                return true;
            }
            // Provides a Condition
            Condition newCondition() {
                return new ConditionObject();
            }
            // Deserializes properly
            private void readObject(ObjectInputStream s)
                    throws IOException, ClassNotFoundException {
                s.defaultReadObject();
                setState(0); // reset to unlocked state
            }
        }
    }
<think>嗯,用户让我谈谈对AQS理解AQS是AbstractQueuedSynchronizer的缩写,对吧?这是Java并发编程中非常重要的一个类。我记得它是在java.util.concurrent.locks包下,由Doug Lea设计的。它的主要作用是为实现同步器提供框架,比如ReentrantLock、Semaphore这些常用的同步工具都是基于AQS构建的。 首先,我需要回顾一下AQS的核心思想。AQS使用了一个int类型的state变量来表示同步状态,通过内置的FIFO队列来管理线程的排队工作。这样,开发者不需要自己处理复杂的线程阻塞和唤醒机制,只需要关注state的获取和释放逻辑。 用户可能想知道AQS的工作原理。比如,state变量是如何被操作的?我记得它是通过CAS(Compare and Swap)操作来保证线程安全的。比如,当线程尝试获取锁时,会检查state的值,如果是0,表示锁没有被占用,然后通过CAS将state设为1,成功的话就获取锁;否则,线程会被放入队列中等待。 接下来,AQS中的队列是CLH队列的变种,这是一个双向队列,每个节点代表一个等待的线程。节点中包含了线程的引用以及等待状态等信息。当线程无法获取锁时,会被构造成节点加入队列尾部,并在适当的时候被唤醒。 然后,用户可能关心的是AQS如何实现不同的同步器。比如,独占模式和共享模式的区别。独占模式下,只有一个线程能获取资源,如ReentrantLock;而共享模式下,多个线程可以同时获取,如Semaphore。AQS通过不同的模板方法来实现这两种模式,比如tryAcquire和tryAcquireShared。 我还需要提到AQS的模板方法模式。开发者需要重写特定的方法,比如tryAcquire、tryRelease、tryAcquireShared、tryReleaseShared等,来定义自己的同步逻辑。而AQS会处理线程的排队、阻塞和唤醒,这样开发者不需要关心底层的队列管理。 可能用户会问,为什么AQS这么重要?因为它抽象出了同步器的核心部分,让开发者可以更专注于业务逻辑,而不必重复实现复杂的线程调度。这也是Java并发包中许多工具高效可靠的原因。 另外,可重入性是如何实现的?比如ReentrantLock,当同一个线程多次获取锁时,state会递增,每次释放递减,直到为0才完全释放。这需要在tryAcquire和tryRelease方法中处理当前线程的判断和state的增减。 还有,AQS如何处理中断和超时?比如tryAcquireNanos方法允许线程在指定时间内获取锁,超时则返回false。而acquireInterruptibly方法支持响应中断,这些都需要在节点状态和唤醒机制中处理。 可能我还需要举几个例子,比如CountDownLatch,它的内部类Sync继承自AQS,初始化时state设为计数器的值,每次countDown()调用releaseShared,而await()调用acquireShared,直到state为0。 不过,用户可能对底层实现细节感兴趣,比如节点的入队和出队过程,如何确保线程安全,以及自旋和阻塞的平衡。比如,在入队时,可能使用CAS来保证原子性,而为了避免过多的CPU自旋,可能会在几次尝试后进入阻塞状态,依赖前驱节点的信号来唤醒。 还有,取消节点的情况如何处理?比如在获取锁超时或中断时,节点需要从队列中移除,并重新调整队列的状态,确保后续节点能正确被唤醒。 可能用户还会问到公平与非公平锁的区别。在AQS中,公平锁严格按照队列顺序获取锁,而非公平锁允许插队,新来的线程可能先尝试获取锁,而不是直接排队,这样提高了吞吐量但可能导致饥饿。 总结一下,AQS通过模板方法将同步状态的管理和线程排队机制抽象出来,让开发者可以灵活实现各种同步器,同时保证了高效和可靠性。理解AQS对于掌握Java并发编程至关重要,它是许多高级同步工具的基础。</think>AQS(AbstractQueuedSynchronizer)是 Java 并发编程的核心基础框架,用于构建锁和其他同步工具(如 `ReentrantLock`、`Semaphore`、`CountDownLatch` 等)。其核心思想是通过 **共享资源的状态管理** 和 **线程排队机制** 实现高效的线程同步。以下是关键点的总结: --- ### **1. 核心思想** - **同步状态(`state`)**: 通过一个 `volatile int` 变量表示资源状态(如锁的持有次数、信号量剩余量等),通过 CAS(Compare and Swap)操作保证原子性修改。 - **队列管理**: 使用一个 **CLH 变体的双向队列**(FIFO)管理竞争资源的线程。队列中的每个节点(`Node`)封装了等待线程的信息及其等待状态(如是否被取消)。 --- ### **2. 核心机制** #### **(1) 资源访问模式** - **独占模式(Exclusive)**: 资源仅允许一个线程持有(如 `ReentrantLock`)。通过 `tryAcquire` 和 `tryRelease` 定义获取/释放逻辑。 - **共享模式(Shared)**: 资源允许多个线程共享(如 `Semaphore`、`CountDownLatch`)。通过 `tryAcquireShared` 和 `tryReleaseShared` 实现。 #### **(2) 线程阻塞与唤醒** - 当线程获取资源失败时,会被封装为 `Node` 加入队列尾部,并通过 `LockSupport.park()` 阻塞。 - 当资源释放时,AQS 按队列顺序唤醒后续节点中的线程(公平性由实现决定)。 --- ### **3. 关键实现细节** #### **(1) 模板方法模式** 开发者需重写以下方法定义资源管理逻辑: - **独占模式**:`tryAcquire(int arg)`、`tryRelease(int arg)` - **共享模式**:`tryAcquireShared(int arg)`、`tryReleaseShared(int arg)` - **是否被当前线程独占**:`isHeldExclusively()` #### **(2) 可重入性** - 如 `ReentrantLock` 通过记录当前持有锁的线程和 `state` 重入次数实现。每次重入时 `state` 递增,释放时递减至 0 才完全释放资源。 #### **(3) 公平性与非公平性** - **公平锁**:严格按队列顺序分配资源,避免饥饿。 - **非公平锁**:允许新线程直接尝试插队获取资源(提高吞吐量)。 --- ### **4. 典型应用** - **ReentrantLock**: 基于 AQS 实现可重入的独占锁,支持公平/非公平策略。 - **Semaphore**: 通过共享模式控制并发线程数,`state` 表示可用许可证数量。 - **CountDownLatch**: `state` 初始化为计数器值,线程调用 `countDown()` 递减,`await()` 阻塞直到 `state` 归零。 --- ### **5. 优势与意义** - **解耦同步逻辑**:AQS 封装了线程排队、阻塞/唤醒等底层操作,开发者只需关注资源状态的管理。 - **高性能**:通过自旋、CAS 和队列优化减少上下文切换。 - **扩展性**:基于模板方法模式,可灵活实现各种同步工具。 --- ### **6. 示例:实现一个简易锁** ```java public class MyLock extends AbstractQueuedSynchronizer { @Override protected boolean tryAcquire(int arg) { if (compareAndSetState(0, 1)) { // CAS 尝试获取锁 setExclusiveOwnerThread(Thread.currentThread()); return true; } return false; } @Override protected boolean tryRelease(int arg) { if (getExclusiveOwnerThread() != Thread.currentThread()) { throw new IllegalMonitorStateException(); } setExclusiveOwnerThread(null); setState(0); // 释放锁 return true; } public void lock() { acquire(1); } public void unlock() { release(1); } } ``` --- ### **总结** AQSJava 并发包的基石,通过将复杂的线程同步问题抽象为 **状态管理** 和 **队列调度**,提供了高度灵活且高效的同步框架。理解其原理对掌握 `ReentrantLock`、`ThreadPoolExecutor` 等工具至关重要,也是优化高并发程序的关键。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值