AQS（抽象队列同步器）详解

最新推荐文章于 2022-06-10 10:21:24 发布
最新推荐文章于 2022-06-10 10:21:24 发布
阅读量563 收藏 2
点赞数
分类专栏： 阶段一：高性能编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maxleader/article/details/104350587
版权

文章目录


同步锁的本质 —— 排队
同步的方式：独享锁 - 单个队列窗口，共享锁 - 多个队列窗口；
抢锁的方式：插队抢（非公平锁）、先来后到抢（公平锁）；
没捡到锁的处理方式：快速尝试多次（CAS自旋锁）、阻塞等待；
唤醒阻塞线程的方式（叫号器）：全部通知、通知下一个；

资源占用流程

资源占用流程

抽象队列同步器AbstractQueuedSynchronizer

AQS

手写AQS
import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.LockSupport;

/**
 * 抽象队列同步器
 * state， owner， waiters
 */
public class MyAqs {

    // 1、 如何判断一个资源的拥有者
    public volatile AtomicReference<Thread> owner = new AtomicReference<>();
    // 保存 正在等待的线程
    public volatile LinkedBlockingQueue<Thread> waiters = new LinkedBlockingQueue<>();
    // 记录资源状态
    public volatile AtomicInteger state = new AtomicInteger(0);

    /**
     * 定义了资源争用的逻辑，如果没拿到，则等待
     */
    public void acquire() {
        boolean addQ = true;
        while (!tryAcquire()) {
            if (addQ) {
                // 没拿到锁，加入到等待集合
                waiters.offer(Thread.currentThread());
                addQ = false;
            } else {
                // 阻塞 挂起当前的线程，不要继续往下跑了
                LockSupport.park(); // 伪唤醒，就是非unpark唤醒的
            }
        }
        waiters.remove(Thread.currentThread()); // 把线程移除
    }

    /**
     * 共享资源占用的逻辑，返回资源的占用情况
     */
    public boolean tryAcquire() { // 交给使用者去实现。 模板方法设计模式
        throw new UnsupportedOperationException();
    }

    /**
     * 定义释放资源的逻辑，释放之后，通知后续节点进行争抢
     */
    public void release() {
        if (tryRelease()) {
            // 通知等待者
            Iterator<Thread> iterator = waiters.iterator();
            while (iterator.hasNext()) {
                Thread next = iterator.next();
                LockSupport.unpark(next); // 唤醒
            }
        }
    }

    /**
     * 实际执行资源释放的操作，具体的AQS使用者去实现
     */
    public boolean tryRelease() {
        throw new UnsupportedOperationException();
    }

    public AtomicInteger getState() {
        return state;
    }

    public void setState(AtomicInteger state) {
        this.state = state;
    }
}
AQS源码解析

要理解AQS，需重点阅读 java.util.concurrent.locks包下的JDK源码；
也可点击阅读并发-AQS源码分析

信号量Semaphore

在这里插入图片描述

手写Semaphore信号量
import com.aqs.MyAqs;

/**
 * 自定义的信号量实现
 */
public class MySemaphore {
    MyAqs aqs = new MyAqs() {
        @Override
        public int tryAcquireShared() { // 信号量获取， 数量 - 1
            for(;;) {
                int count =  getState().get();
                int n = count - 1;
                if(count <= 0 || n < 0) {
                    return -1;
                }
                if(getState().compareAndSet(count, n)) {
                    return 1;
                }
            }
        }

        @Override
        public boolean tryReleaseShared() { // state + 1
            return getState().incrementAndGet() >= 0;
        }
    };

    /** 许可数量 */
    public MySemaphore(int count) {
        aqs.getState().set(count); // 设置资源的状态
    }

    /** 获取令牌 */
    public void acquire() {
        aqs.acquireShared();
    }

    /** 释放令牌 */
    public void release() {
        aqs.releaseShared();
    }
}

信号量用法代码示例：

import java.util.Random;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 信号量机制
 */
public class SemaphoreDemo {
    public static void main(String[] args) {
        SemaphoreDemo semaphoreTest = new SemaphoreDemo();
        int N = 9;            // 客人数量
        Semaphore semaphore = new Semaphore(5);	// 手牌数量，限制请求数量
        for (int i = 0; i < N; i++) {
            String vipNo = "vip-00" + i;
            new Thread(() -> {
                try {
                    semaphore.acquire(); // 获取令牌
                    semaphoreTest.service(vipNo);
                    semaphore.release(); // 释放令牌
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }

    // 限流 控制5个线程 同时访问
    public void service(String vipNo) throws InterruptedException {
        System.out.println("楼上出来迎接贵宾一位，贵宾编号" + vipNo + "，...");
        Thread.sleep(new Random().nextInt(3000));
        System.out.println("欢送贵宾出门，贵宾编号" + vipNo);
    }
}
Semaphore源码解析
import java.util.Collection;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

// Semaphore 源码解析版本
public class SemaphoreSource {
    private final SemaphoreSource.Sync sync;
    // 还是AQS的机制
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 1192457210091910933L;

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

        final int getPermits() {
            return getState();
        }

        final int nonfairTryAcquireShared(int acquires) {
            for (; ; ) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                        compareAndSetState(available, remaining)) {
                    return remaining;
                }
            }
        }

        @Override
        protected final boolean tryReleaseShared(int releases) {
            for (; ; ) {
                int current = getState();
                int next = current + releases;
                if (next < current){     // overflow
                    throw new Error("Maximum permit count exceeded");
                }
                if (compareAndSetState(current, next)) {
                    return true;
                }
            }
        }

        final void reducePermits(int reductions) {
            for (; ; ) {
                int current = getState();
                int next = current - reductions;
                if (next > current) {   // overflow
                    throw new Error("Permit count underflow");
                }
                if (compareAndSetState(current, next)) {
                    return;
                }
            }
        }

        final int drainPermits() {
            for (; ; ) {
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0)) {
                    return current;
                }
            }
        }
    }

    static final class NonfairSync extends SemaphoreSource.Sync {
        private static final long serialVersionUID = -2694183684443567898L;

        NonfairSync(int permits) {
            super(permits);
        }

        @Override
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

    static final class FairSync extends SemaphoreSource.Sync {
        private static final long serialVersionUID = 2014338818796000944L;

        FairSync(int permits) {
            super(permits);
        }

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

    public SemaphoreSource(int permits) {
        sync = new SemaphoreSource.NonfairSync(permits);
    }

    public SemaphoreSource(int permits, boolean fair) {
        sync = fair ? new SemaphoreSource.FairSync(permits) : new SemaphoreSource.NonfairSync(permits);
    }

    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    public void acquireUninterruptibly() {
        sync.acquireShared(1);
    }

    public boolean tryAcquire() {
        return sync.nonfairTryAcquireShared(1) >= 0;
    }

    public boolean tryAcquire(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void release() {
        sync.releaseShared(1);
    }

    public void acquire(int permits) throws InterruptedException {
        if (permits < 0) {
            throw new IllegalArgumentException();
        }
        sync.acquireSharedInterruptibly(permits);
    }

    public void acquireUninterruptibly(int permits) {
        if (permits < 0) {
            throw new IllegalArgumentException();
        }
        sync.acquireShared(permits);
    }

    public boolean tryAcquire(int permits) {
        if (permits < 0) {
            throw new IllegalArgumentException();
        }
        return sync.nonfairTryAcquireShared(permits) >= 0;
    }

    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
            throws InterruptedException {
        if (permits < 0) {
            throw new IllegalArgumentException();
        }
        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
    }

    public void release(int permits) {
        if (permits < 0) {
            throw new IllegalArgumentException();
        }
        sync.releaseShared(permits);
    }

    public int availablePermits() {
        return sync.getPermits();
    }

    public int drainPermits() {
        return sync.drainPermits();
    }

    protected void reducePermits(int reduction) {
        if (reduction < 0) {
            throw new IllegalArgumentException();
        }
        sync.reducePermits(reduction);
    }

    public boolean isFair() {
        return sync instanceof SemaphoreSource.FairSync;
    }

    public final boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }

    public final int getQueueLength() {
        return sync.getQueueLength();
    }

    protected Collection<Thread> getQueuedThreads() {
        return sync.getQueuedThreads();
    }

    @Override
    public String toString() {
        return super.toString() + "[Permits = " + sync.getPermits() + "]";
    }
}

倒计数器CountDownLatch

CountDownLatch
类似比赛开始前，裁判等待运动员就绪后，吹哨开始比赛；

手写CountDownLatch倒计数器
import com.study.lock.aqs.MyAqs;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * CountDownLatch 自己实现
 */
public class CountDownLatchDemo {
    MyAqs aqs = new MyAqs() {
        @Override
        public int tryAcquireShared() { // 如果非等于0，代表当前还有线程没准备就绪，则认为需要等待
            return this.getState().get() == 0 ? 1 : -1;
        }

        @Override
        public boolean tryReleaseShared() { // 如果非等于0，代表当前还有线程没准备就绪，则不会通知继续执行
            return this.getState().decrementAndGet() == 0;
        }
    };

    public CountDownLatchDemo(int count) {
        aqs.setState(new AtomicInteger(count));
    }

    public void await() {
        aqs.acquireShared();
    }

    public void countDown() {
        aqs.releaseShared();
    }

    public static void main(String[] args) throws InterruptedException {
        // 一个请求，后台需要调用多个接口 查询数据
        CountDownLatch cdLdemo = new CountDownLatch(10); // 创建，计数数值
        for (int i = 0; i < 10; i++) { // 启动九个线程，最后一个两秒后启动
            int finalI = i;
            new Thread(() -> {
                try {
                    Thread.sleep(2000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("我是" + Thread.currentThread() + ".我执行接口-" + finalI +"调用了");
                cdLdemo.countDown(); // 参与计数
                // 不影响后续操作
            }).start();
        }

        cdLdemo.await(); // 等待计数器为0
        System.out.println("全部执行完毕.我来召唤神龙");
    }
}
CountDownLatch源码解析
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;

// CountDownLatch 源码解析版
public class CountDownLatchSource {
    private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;

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

        int getCount() {
            return getState();
        }

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

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

    private final CountDownLatchSource.Sync sync;

    public CountDownLatchSource(int count) {
        if (count < 0) {
            throw new IllegalArgumentException("count < 0");
        }
        this.sync = new CountDownLatchSource.Sync(count);
    }

    public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    public boolean await(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
    }

    public void countDown() {
        sync.releaseShared(1);
    }

    public long getCount() {
        return sync.getCount();
    }

//    public String toString();
}

栅栏CyclicBarrier

CyclicBarrier

手写CyclcBarrier栅栏
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.LinkedBlockingQueue;

// 循环屏障(栅栏)，示例：数据库批量插入
// 游戏大厅... 5人组队打副本
public class CyclicBarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingQueue<String> sqls = new LinkedBlockingQueue<>();
        // 任务1+2+3...1000  拆分为100个任务（1+..10,  11+20） -> 100线程去处理。

        // 每当有4个线程处于await状态的时候，则会触发barrierAction执行
        CyclicBarrier barrier = new CyclicBarrier(4, new Runnable() {
            @Override
            public void run() {
                // 这是每满足4次数据库操作，就触发一次批量执行
                System.out.println("有4个线程执行了，开始批量插入： " + Thread.currentThread());
                for (int i = 0; i < 4; i++) {
                    System.out.println(sqls.poll());
                }
            }
        });

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                try {
                    sqls.add("data - " + Thread.currentThread()); // 缓存起来
                    Thread.sleep(1000L); // 模拟数据库操作耗时
                    barrier.await(); // 等待栅栏打开,有4个线程都执行到这段代码的时候，才会继续往下执行
                    System.out.println(Thread.currentThread() + "插入完毕");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }

        Thread.sleep(2000);
    }
}
CyclcBarrier源码解析
// CyclicBarrier 源码解析版
public class CyclicBarrier {
    private static class Generation {
        boolean broken = false;
    }

    private final ReentrantLock lock = new ReentrantLock();
    private final Condition trip = lock.newCondition();
    private final int parties;
    private final Runnable barrierCommand;
    private Generation generation = new Generation();

    private int count;

    private void nextGeneration() {
        trip.signalAll(); // 唤醒线程
        count = parties; // count重置
        generation = new Generation();
    }
    
    /** 跳出栅栏，标记破碎了 */
    private void breakBarrier() {
        generation.broken = true;
        count = parties;
        trip.signalAll();
    }

    private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
            TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock(); // 一个线程拿到锁
        try {
            final Generation g = generation;

            if (g.broken) // 一个报错，大家都报错
                throw new BrokenBarrierException();

            if (Thread.interrupted()) {
                breakBarrier(); // 如果线程被中断，唤醒目前正在等待的线程。
                throw new InterruptedException();
            }

            int index = --count;
            if (index == 0) {  // tripped 数量够了
                boolean ranAction = false;
                try {
                    final Runnable command = barrierCommand;
                    if (command != null)
                        command.run(); // 触发执行指定的任务
                    ranAction = true;
                    nextGeneration(); // 唤醒等待的线程继续执行。重新计数
                    return 0;
                } finally {
                    if (!ranAction) // 执行出现异常，不为true则设置
                        breakBarrier();
                }
            }

            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    if (!timed) // 如果没设置超时时间，就直接进入等待
                        trip.await();
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos); // 进入带有超时机制的等待
                } catch (InterruptedException ie) {
                    if (g == generation && ! g.broken) {// 中途线程被中断，则标记
                        breakBarrier();
                        throw ie;
                    } else {
                        // We're about to finish waiting even if we had not
                        // been interrupted, so this interrupt is deemed to
                        // "belong" to subsequent execution.
                        Thread.currentThread().interrupt();
                    }
                }

                if (g.broken)
                    throw new BrokenBarrierException();

                if (g != generation)
                    return index;

                if (timed && nanos <= 0L) { // 等待超时
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

    public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) {
            throw new IllegalArgumentException();
        }
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
    }

    public CyclicBarrier(int parties) {
        this(parties, null);
    }
    public int getParties() {
        return parties;
    }

    public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen
        }
    }

    public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }

    public boolean isBroken() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return generation.broken;
        } finally {
            lock.unlock();
        }
    }

    public void reset() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            breakBarrier();   // break the current generation
            nextGeneration(); // start a new generation
        } finally {
            lock.unlock();
        }
    }

    public int getNumberWaiting() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return parties - count;
        } finally {
            lock.unlock();
        }
    }
}
maxleader
关注
专栏目录
AQS 抽象队列同步器详解
qq_56263094的博客
07-23 409
AQS，英文名是AbstractQueuedSychronizer，翻译过来就是抽象队列同步器可以看我们的java.util.concurrent.locks下面，会发现AQS其实就是一个抽象类AQS为构建锁和同步器提供了一些通用功能的是实现，因此，使用AQS能简单且高效地构造出应用广泛的大量的同步器，比如我们提到的ReentrantLock，Semaphore等等。......
AQS队列同步器详解
最新发布
weixin_52195362的博客
02-02 457
AQS队列同步器
浅谈AQS（抽象队列同步器）
weixin_33834075的博客
06-04 391
概念 AQS，全称AbstractQueuedSynchronizer，即抽象队列同步器，和CAS共同撑起了整个java.util.concurrent包，同时也是Java并发编程上绕不开的一个概念 抽象队列同步器，以下统称AQS，用于解决的就是多线程并发访问控制问题。在传统的多线程编程中，如果有多个线程需要访问同一个变量，就需要使用synchronized来为临界区加锁（临界区：访问共享资源的程...
java-AQS(抽象队列同步器)
好记性不如烂笔头
02-28 594
AQS原理： 当线程请求的共享资源空闲时，将资源设置为锁定状态，同时将当前线程设置为工作线程 当其他线程来请求当前被锁定的资源时，将其暂时放到一个队列当中（基于CLH队列实现） CLH队列锁帮助实现其他线程的挂起等待以及唤醒、分配锁功能 注：CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQ...
抽象队列同步器AQS（AbstractQueuedSynchronizer）
张矜持的博客
02-08 1308
AQS（AbstractQueuedSynchronizer）
AQS（抽象队列同步器）
青鱼入云的博客
05-20 1780
一、什么是 AQS ？ AQS即AbstractQueuedSynchronizer的缩写，是并发编程中实现同步器的一个框架。 AQS基于一个FIFO双向队列实现，被设计给那些依赖一个代表状态的原子int值的同步器使用。我们都知道，既然叫同步器，那个肯定有个代表同步状态（临界资源）的东西，在AQS中即为一个叫state的int值，该值通过CAS进行原子修改。 在AQS中存在一个...
Jdk源码——AQS同步队列解析
等一杯咖啡的博客
12-26 526
前言 本文主要参考自《Java 并发编程的艺术》第五章内容，结合源码对书中内容进行分析补充。 I. Lock接口 在 Lock 接口出现之前，Java程序是靠 synchronized 关键字实现锁功能的，而 Java SE 5 之后，并发包中新增了 Lock 接口（以及相关实现类）用来实现锁功能，它提供了与 synchronized 关键字类似的同步功能，只是在使用时需要显式地获取和释放锁。...
队列同步器(AbstractQueuedSynchronizer)源码简析
Stay Hungry, Stay Foolish!
06-09 911
文章目录1 AQS概述2 AQS常用方法2 AQS实现分析2.1 同步队列2.1.1 入队2.1.2 出列2.2 同步状态2.2.1 独占式(EXCLUSIVE)2.2.2 共享式(SHARED)2.2.3 超时获取方式2.3 阻塞和唤醒线程2.3.1 parkAndCheckInterrupt2.3.2 unparkSuccessor2.3.3 LockSupport3 总结参考资料 文章后续于https://github.com/zgkaii/CS-Study-Notes更新，欢迎批评指正！ 1 A
Java多线程——Lock锁机制与AQS同步器流程
xiaoaxiao
07-18 503
Java多线程——Lock锁机制 一、Lock锁总结   1、Lock接口与AQS的关系    Lock接口的最主要实现类 ReentrantLock中所有的方法实际上都是调用了其静态内部类Sync中的方法    而Sync继承了AbstractQueuedSynchronizer(AQS-简称"同步器")   2、Lock与synchronize的区别    ①synchronized内建锁有...
JAVA AQS抽象队列同步器详解
Heqianqian的博客
09-21 1952
之前看到一篇很好的介绍AQS抽象队列同步器的文章，分享下。框架维护了一个state（代表共享资源，注意是volatile修饰的保证可见性）和一个FIFO线程等待队列（多线程争用资源被阻塞时会进入此队列）state的访问方式有三种： getState() setState() compareAndSetState() AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如Reen
AQS抽象队列同步器详解(待更新)
Thxxxxxx
04-27 260
AQS抽象的队列同步器
kylin's study
04-06 212
AQS是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石
抽象同步队列AQS
CodePanda@GPF的博客
04-07 634
同步队列AQS
12、AbstractQueuedSynchronizer之AQS
赞的心路历程
06-10 466
公平锁和非公平锁可重入锁自旋锁LockSupport数据结构之链表设计模式之模板设计模式抽象的队列同步器源代码 AbstractOwnableSynchronizer AbstractQueuedLongSynchronizer AbstractQueuedSynchronizer 通常地：AbstractQueuedSynchronizer简称为AQS 是用来构建锁或者其它同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工
AQS抽象队列同步器
weixin_47407737的博客
03-04 169
AQS原理及组件的介绍
抽象队列同步器AQS
lym3lavender的博客
09-17 197
AQS抽象队列同步器 AQS简介 AQS源码简介 Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on first-in-first-out (FIFO) wait queues. This class is des...
AQS(AbstractQueuedSynchronizer)抽象队列同步器
聪明不喝牛奶的博客
03-24 395
前言 AQS 绝对是JUC的重要基石，也是面试中经常被问到的，所以我们要搞清楚这个AQS到底是什么？骑工作原理是什么？ AQS是什么？ 是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO对列来完成资源获取线程的排队工作，并通过一个int类型变量表示持有锁的状态。 CLH队列：CLH(Craig, Landin, and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS 是将每条请求共享资源的线程封装成一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值