JUC并发编程03——AQS条件队列源码剖析

最新推荐文章于 2024-09-09 16:24:36 发布
最新推荐文章于 2024-09-09 16:24:36 发布
阅读量181 收藏
点赞数
文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2312/article/details/128529215
版权

上一节我们在分析AQS源码时知道，AQS内部维护了一个同步状态位state和一个虚拟的同步队列来实现锁的争抢，其实除此以外还维护了一个条件队列。这个条件队列也不神秘，我们在开发中或多或少都使用过JUC的Conditon，用来做多个线程之间的等待唤醒，它的底层就是我们今天要说的AQS的条件队列。

我们先用一张图来看下AQS的内部结构：

上一节我们主要分析了AQS的CLH等待队列，今天我们着重来分析下条件队列的源码。

我们先看下AQS的ConditionObject类的结构：

public class ConditionObject implements Condition, java.io.Serializable {
    private static final long serialVersionUID = 1173984872572414699L;
    /** 
     * 条件队列的第一个节点
     */
    private transient Node firstWaiter;
    /**
     * 条件队列的最后一个节点
     */
    private transient Node lastWaiter;
    
    //重写Conditon接口的方法
    {
        //等待
        void await() throws InterruptedException;

        //.......

        //唤醒
        void signal();

        void signalAll();

    }
}    
复制代码

从类结构上不难看出，它也是使用Node作为队列的节点，前面我们分析AQS源码时已经看过了Node的组成结构，这里就不再看了。

我们以一个常见的面试题引出我们今天要讲的条件队列，就是3个线程顺序打印A-B-C, 我们先看下演示代码：

/**
 * @author qiuguan
 * @date 2022/12/10 22:48:23  星期六
 *
 * 控制线程打印A - B - C
 */
public class LockConditionDemo {

    private final Lock lock = new ReentrantLock();
    /**
     * lock.newCondition()就是创建了一个上面的 ConditionObject 对象
     * 一共创建了3个 ConditionObject 对象
     */
    private final Condition c1 = lock.newCondition();
    private final Condition c2 = lock.newCondition();
    private final Condition c3 = lock.newCondition();

    private  int flag = 0;

    public  void printA(){
        lock.lock();
        try {
            while (flag != 0) {
                try {
                    c1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("--------------> A");
            flag++;
            c2.signal();
        } finally {
            lock.unlock();
        }
    }

    public  void printB(){
        lock.lock();
        try {
            while (flag != 1) {
                try {
                    c2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("--------------> B");
            flag++;
            c3.signal();
        } finally {
            lock.unlock();
        }
    }

    public  void printC(){
        lock.lock();
        try {
            while (flag != 2) {
                try {
                    c3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println("--------------> C");
            flag = 0;
            c1.signal();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        LockConditionDemo lc = new LockConditionDemo();
        new Thread(lc::printC, "tc").start();
        new Thread(lc::printB, "tb").start();
        new Thread(lc::printA, "ta").start();
    }
}
复制代码

从代码中我们可以清晰的知道，tc,tb,ta 三个线程分别调用各自的方法，然后各自执行lock.lock()方法，其中只有一个线程能获得锁，获取不到锁的线程将会进入等待队列。我们建设tc线程率先获得锁，然后tb线程,ta线程先后进入等待队列。

tc线程优先获得锁

public  void printC(){
    //tc线程过来获取锁
    lock.lock();
    try {
        while (flag != 2) {
            try {
                c3.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("--------------> C");
        flag = 0;
        c1.signal();
    } finally {
        lock.unlock();
    }
}
复制代码

tc线程先执行，它会调用printC方法，进而执行lock.lock()方法，这个我们前面分析AQS的时候知道，tc线程进来会将同步状态位state从0修改为1，表示获取锁，然后继续往下执行，由于flag != 2条件成立，所以将会执行c3.await()的逻辑，到这里就要带领我们走进AQS的条件队列。接下来我们就看下c3.await() 具体都做了什么？我们直接看源码：

public final void await() throws InterruptedException {
    //如果线程是中断的，则抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //1. 创建一个条件队列的节点    
    Node node = addConditionWaiter();
    //2. 释放锁，核心逻辑就是lock.unlock()方法的内容
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //3. 判断是否在同步队列中，也就是前面说的CLH同步队列
    while (!isOnSyncQueue(node)) {
        //不在同步队列中，挂起
        LockSupport.park(this);
        //被唤醒后接着往下执行，然后checkInterruptWhileWaiting(node))方法会将当前
        //node加入到同步队列中（入队：入的是同步队列)
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //acquireQueued(node, savedState)这个方法就比较熟悉了，前面分析AQS的时候着重说过
    //它就是加入同步队列后，等待被唤醒，然后去抢锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}
复制代码

这个方法在AbstractQueuedSynchronizer（AQS）类中

我们先看下创建条件队列节点的方法：addConditionWaiter()

private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    //创建一个Node节点，waitStatus 是 Node.CONDITION
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    //整个逻辑就是尾插法插入到条件队列的尾部
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    
    return node;
}
复制代码

我们用一张图来看下入条件队列：

我们用一张图来描述下tc线程的await()方法都干了什么

从图中我们知道，tc线程加入条件队列后，会唤醒等待队列中等待的线程，然后将自己挂起。然后接下来我们看下唤醒tb线程(FIFO)后，tb线程都做了什么？

唤醒tb线程

public  void printB(){
    lock.lock();
    try {
        while (flag != 1) {
            try {
            
                c2.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("--------------> B");
        flag++;
        c3.signal();
    } finally {
        lock.unlock();
    }
}
复制代码

tb线程获得锁后，将从lock.lock()继续往下执行，然后来到c2的await()方法中，那这就比较熟悉了，因为它和tc线程是一样的。

  1. 首先tb线程要加入条件队列（注意：这个条件队列和tc线程不是同一个，因为他们是分别newCondition获得的)

  1. 然后我们再看下tb线程的awiat()方法做了什么？

从图中我们很清晰的知道，tb线程加入条件队列后，会唤醒等待队列中等待的线程，然后将自己挂起。然后接下来我们看下唤醒ta线程后，ta线程都做了什么？

唤醒ta线程

public  void printA(){
    lock.lock();
    try {
        while (flag != 0) {
            try {
                c1.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("--------------> A");
        flag++;
        c2.signal();
    } finally {
        lock.unlock();
    }
}
复制代码

ta线程获得锁后，将从lock.lock()继续往下执行，由于它不满足while条件，所以它先打印 "--------------> A"，然后将执行c2.signal() 方法，那么接下来我们就看下这个方法都做了什么？

注意：是c2的signal()方法

public final void signal() {
    //判断当前的线程是否为持有锁的线程,tb线程
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //找到条件队列中的第一个first节点
    Node first = firstWaiter;
    if (first != null)
        //唤醒
        doSignal(first);
}
复制代码

这里的firstWaiter节点是封装了tb线程的Node节点

我们继续跟进去看下：

private void doSignal(Node first) {
    //整个do逻辑是将节点从头到尾一个一个的从条件队列中移除
    do {
        //这里的逻辑就是看下条件队列是不是只有一个节点
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        //if条件里已经完成了赋值操作，将下一个节点推到了首节点    
        first.nextWaiter = null;
             //重点是transferForSignal(first) 方法
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}
复制代码

我们接着看下transferForSignal(first) 方法：

这个方法的逻辑就是将条件队列的节点转移到同步队列中

final boolean transferForSignal(Node node) {
    /*
     * 如果CAS修改失败，说明这个节点已经被取消了
     * 一旦被取消了，就重新执行上面的do-while循环
     */
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    /*
     * CAS状态修改成功，将条件状态修改为了初始值0
     */
    //入队：入的是"等待队列"的队 ,并返回前驱节点
    Node p = enq(node);
    int ws = p.waitStatus; //查看前驱节点的状态，默认值0
    
    //CAS 将前驱节点的状态修改为-1（具有唤醒下一个节点的责任)，如果成功，返回true,
    // 如果失败，返回false,取反后则将进入if判断的内部逻辑，也就是唤醒线程
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}
复制代码

这个方法执行完

  1. 条件队列变成了这样：

  1. 同步队列就变成了这样：

然后退出c2.signal()法方法，然后执行printA()方法的lock.unlock();，这个方法就比较熟悉了，前面讲AQS基础的时候有说过，这里我们在简单看下：

public final boolean release(int arg) {
    //ta线程释放锁
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            //唤醒后继节点
            unparkSuccessor(h);
        return true;
    }
    return false;
}
复制代码

在这个方法中，将会调用LockSupport.unpark(s.thread);唤醒tb线程

我们看下之前tb线程park的地方:

然后tb线程将会继续往下执行，由于它已经在同步队列中了，所以将会退出while循环，然后执行acquireQueued方法，这个方法我们也比较熟悉了，就是尝试获取锁，如果获取不到就继续在同步队列中park。

由于tb线程此时可以获取锁，所以它将不会再继续park,继续往下执行业务代码，将会打印"--------------> B"

然后tb线程继续执行c3.signal()方法，继续去唤醒tc线程，然后打印"--------------> C"

好了，关于AQS的条件队列就分析到这里吧，可能阅读起来比较复杂，限于作者水平有限，不能更好的表达，敬请谅解。

作者：秋官

原文链接：https://juejin.cn/post/7182869415321403449

职场面试官
关注
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7423
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
并发源码解析（三）--AQS条件队列
Double____C的博客
10-17 341
一、条件队列 AQS的一个锁可以对应多个条件变量。使用时先使用lock.newCondition()来new出来一个在AQS内部声明的ConditionObject对象，ConditionObject是AQS的内部类，可以访问AQS内部的变量和方法。而在每个条件变量内部都维护了一个条件队列，用来存放调用条件变量的await()方法时被阻塞的线程。 这个条件队列和AQS队列不是一样东西！ 二、源码分...
深入浅出AQS之条件队列
weixin_34232363的博客
09-30 246
相比于独占锁跟共享锁，AbstractQueuedSynchronizer中的条件队列可能被关注的并不是很多，但它在阻塞队列的实现里起着至关重要的作用，同时如果想全面了解AQS，条件队列也是必须要学习的。 原文地址：www.jianshu.com/p/3f8b08ca2… 这篇文章会涉及到AQS中独占锁跟共享锁的一些知识，如果你已经对这两块内容很了解了，那就直接往下看。否则在读本文之前还是建议...
AQS的同步队列和条件队列原理
HGW的博客
08-10 737
AQS中的 同步队列 和 条件队列 是两种不同队列，同步队列主要用于实现锁机制（也就是锁的获取和释放），而条件队列用于实现条件变量，条件变量是并发编程中一种用于线程间通信的机制，它允许一个或多个线程在特定条件成立之前等待并释放相关的锁，直到其他线程改变了条件并显式的唤醒等待在该条件中的线程。比较典型的一个条件队列使用场景就是 ReentrantLock 的 Condition。
Java并发编程-AQS源码之条件队列
java_dazhuzhu的博客
08-12 193
前言 前面介绍了CLH同步队列,但是AQS内部类还有一个 ConditionObject, 条件队列就是由ConditionObject 维护的队列. Contition是一种广义上的条件队列，它利用await()和signal()为线程提供了一种更为灵活的等待/通知模式。 1. Condition接口 我们知道任意一个对象,都有一组监视器方法,定义在java.lang.Object类上,主要包括wait()、wait(long timeout)、notify()以及notifyAll()方法，这些
AQS——条件队列
wildfire
07-31 691
条件队列的结构以及await()/signal()的使用 等待队列由AQS内部的ConditionObject实现，它实现了Condition接口的方法await()/signal()等，ConditionObject内部维护了一个头节点和一个尾节点，利用AQS内部Node节点的nextWaiter实现了单向等待队列。 条件队列的产生，是由于同步队列中获取到资源的节点由于某种条件被挂起从而加入...
AQS--条件队列（待整理）
TingBen的博客
07-08 387
//条件队列属性： 只有两个属性 firstWaiter 和 lastWaiter； public class ConditionObject implements Condition, java.io.Serializable { private static final long serialVersionUID = 1173984872572414699L; ...
java并发编程：juc、aqs
08-09
Java并发编程中的`JUC`(Java Util Concurrency)库是Java平台中用于处理多线程问题的核心工具包，它提供了一系列高效、线程安全的工具类，帮助开发者编写并发应用程序。`AQS`(AbstractQueuedSynchronizer)是JUC库中的...
JUC——AQS原理分析
xiaowanziddd的博客
08-13 301
AQS在java源码中主要是指AbstractQueuedSynchronizer（抽象队列同步器）抽象类。它整体就是一个抽象的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型变量表示持有锁的状态。
JUC源码学习笔记1——AQS和ReentrantLock
xuhss_com的博客
07-11 205
一丶Lock 锁是用来控制多个线程访问共享资源的方式，一般来说，一个锁可以防止多个线程同时访问共享资源（这种锁称为独占锁，排他锁）但是有些锁可以允许多个线程并发访问共享资源，比如读写锁 3.使用Lock的经典范式 获取锁的过程不要写在try中，避免获取锁失败最后finally释放其他线程持有的锁使用一个int成员变量state表示同步状态，内置的FIFO队列来完成资源的获取和线程的排队工作，支持独占也支持共享的获取同步状态。三个变量被volatile修饰，保证其线程可见性等待状态是一个枚举，具备下列可选的值
Java并发编程（27）—— 队列同步器（AQS）的设计原理
最新发布
shangjg3的博客
09-09 211
因为head节点是当前线程创建的，而当前线程只知道有线程获取到了同步状态，但是却不知道是谁获取到了，所以此时当前线程在初始化head节点的时候，只能让head节点的thread属性为null。当前节点代表的线程，如果当前线程获取到了锁，那么当前线程所代表的节点一定处于同步队列的队首，且thread属性为null，至于为什么要将其设置为null，这是AQS特意设计的。独占式获取同步状态，如果线程成功获取了同步状态，则方法会返回，如果没有获取到同步状态，那么当前线程就会进入到同步队列中，并阻塞。
带你看看Java-AQS同步器 源码解读四 条件队列Condition上
12-21
Java-AQS同步器 源码解读-条件队列Condition前文为什么需要条件队列Conditon Queue举个小例子分析怎么使用条件队列写个小DemoJDK中是怎么使用的Lock和ConditionLockConditionSync-Queue和Conditian-QueueAQS Condition的实现条件队列-await源码分析条件队列-signal源码分析总结 Java-AQS同步器 源码解读1-独占锁加锁 Java-AQS同步器 源码解读2-独占锁解锁 Java-AQS同步器 源码解读3-共享锁 Java-AQS同步器 源码解读4-条件队列上 前文 AQS的源码分析已经写了篇了，
AQS之条件队列（独占模式）
nobaldnolove的博客
07-25 918
AQS 之 CONDITION 条件队列
走进AQS体系（二）—— 条件队列
ADi_1998的博客
07-09 1830
条件队列在 并发编程中是用于对一类事务在处理时机未到的情况下，让负责处理此类事务的线程进行阻塞，当时机成熟的时候，将其唤醒，使其继续往下处理这件事务； 条件队列针对阻塞于某类条件的线程进行集中化的队列管理，能保证当该条件成熟了 ，这些线程能够按照有序的方式一个个转换到同步队列中； 需要区分两种唤醒，条件队列的唤醒，是每次唤醒后会将其转换到同步队列，最终这些条件队列上的CONDITION节点都是转换到同步队列中的；同步队列的唤醒，是去争夺处理机，真正去执行线程内容；所以，第一个唤醒不考虑
多线程 | AQS | 条件队列 Condition 源码分析
程序员阿康
02-11 966
1）条件队列概念： 条件队列是当某个条件不满足状态时，挂起自己并释放锁，一旦等待条件为真，则立即醒来。这也是条件队列提供的主要功能。 Object的wait/notify/notifyAll等方法构成了内部条件队列的API，在lock中又是怎么实现的呢？ 就是这里要讨论的条件队列 condition。 具体使用示例就不展示了，和 wait/notify/notifyAll 使用场景类似...
条件队列
weixin_40839342的博客
07-25 385
wait()、notify()和notifyAll()一般是跟synchronized配合一起使用，这些方法都是Object类提供的。 当线程重wait()状态下被唤醒，wait()在被唤醒后还需要重新去获取锁，此时它重新请求锁时并没有具备任何特殊的优先级， 要与任何其他尝试进入同步代码块的线程一起去竞争获取锁，如果获取锁失败的话，会继续停留在当前的wait()方法状态下。 所以wait方法继续...
Java并发工具AQS条件队列Condition实现详解
zhuguang10的博客
07-19 1087
你是否使用过java并发工具包中的Lock和Condition。本文分析一下JDK是如何实现Condition条件队列的，对你今后的使用或许有帮助。如果你觉得分析源码太累，看不懂，可以通过阅读本文以大致了解java显式锁的实现，保证你面试够用了。 约定： 本文AQS均指java.util.concurrent.locks.AbstractQueuedSynchronizer类。 本文CAS操...
从 ArrayBlockingQueue 探究 AQS 细节 — 条件队列篇
2301_76607156的博客
03-31 362
条件队列是指一个阻塞队列，其中的元素是等待某个条件成立的线程。在 Java 的同步机制中，条件队列通常用于实现线程等待和唤醒的操作。当条件不满足时，线程会被加入到条件队列中等待；当条件满足时，线程会被从条件队列中移除并继续执行。
Java并发编程深度解析：JUC与AQS核心机制
"深入理解Java并发编程的JUC库与AQS机制对于提升多线程应用的性能至关重要。AQS（AbstractQueuedSynchronizer）作为JUC的核心组件，提供了构建自定义同步器的基础，支持独占锁和共享锁的实现。AQS内部维护的等待队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值