AQS中的Condition是什么？

最新推荐文章于 2024-08-21 00:03:46 发布
最新推荐文章于 2024-08-21 00:03:46 发布
阅读量226 收藏 1
点赞数
文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/130740869
版权

今天来和大家聊聊Condition，Condition为AQS“家族”提供了等待与唤醒的能力，使AQS"家族"具备了像synchronized一样暂停与唤醒线程的能力。我们先来看两道关于Condition的面试题目：

  • Condition和Object的等待与唤醒有什么区别？
  • 什么是Condition队列？

接下来，我们就按照“是什么”，“怎么用”和“如何实现”的顺序来揭开Condition的面纱吧。

Condition是什么？

Condition是Java中的接口，提供了与Object#wait和Object#notify相同的功能。Doug Lea在Condition接口的描述中提到了这点：

Conditions (also known as condition queues or condition variables) provide a means for one thread to suspend execution (to "wait") until notified by another thread that some state condition may now be true.

来看Condition接口中提供了哪些方法：

 

Java
 

复制代码
 

public interface Condition { void await() throws InterruptedException; void awaitUninterruptibly(); long awaitNanos(long nanosTimeout) throws InterruptedException; boolean await(long time, TimeUnit unit) throws InterruptedException; boolean awaitUntil(Date deadline) throws InterruptedException; void signal(); void signalAll(); } 
 

Condition只提供了两个功能：等待（await）和唤醒（signal），与Object提供的等待与唤醒时相似的：
 

 

Java
 

复制代码
 

public final void wait() throws InterruptedException; public final void wait(long timeoutMillis, int nanos) throws InterruptedException; public final native void wait(long timeoutMillis) throws InterruptedException; @HotSpotIntrinsicCandidate public final native void notify(); @HotSpotIntrinsicCandidate public final native void notifyAll(); 
 

唤醒功能上，Condition与Object的差异并不大：
 

  • Condition#signal≈\approx≈Object#notify
  • Condition#signalAll===Object#notifyAll
 

多个线程处于等待状态时，Object#notify()是“随机”唤醒线程，而Condition#signal则由具体实现决定如何唤醒线程，如：ConditionObject唤醒的是最早进入等待的线程，但两个方法均只唤醒一个线程。
 

等待功能上，Condition与Object的共同点是：都会释放持有的资源，Condition释放锁，Object释放Monitor，即进入等待状态后允许其他线程获取锁/监视器。主要的差异体现在Condition支持了更加丰富的场景，通过一张表格来对比下：
 

Condition方法Object方法解释
Condition#await()Object#wait()暂停线程，抛出线程中断异常
Condition#awaitUninterruptibly()/暂停线程，不抛出线程中断异常
Condition#await(time, unit)Object#wait(timeoutMillis, nanos)暂停线程，直到被唤醒或等待指定时间后，超时后自动唤醒返回false，否则返回true
Condition#awaitUntil(deadline)/暂停线程，直到被唤醒或到达指定时间点，超时后自动唤醒返回false，否则返回true
Condition#awaitNanos(nanosTimeout)/暂停线程，直到被唤醒或等待指定时间后，返回值表示被唤醒时的剩余时间（nanosTimeout-耗时），结果为负数表示超时
 

除了以上差异外，Condition还支持创建多个等待队列，即同一把锁拥有多个等待队列，线程在不同队列中等待，而Object只有一个等待队列。《Java并发编程的艺术》中也有一张类似的表格，放在这里供大家参考：
 

 

Tips：
 

  • 实际上signal翻译为唤醒并不恰当~~
  • 涉及到Condition的实现部分，下文通过AQS中的ConditionObject详细解释。
 

Condition怎么用？
 

既然Condition与Object提供的等待与唤醒功能相同，那么它们的用法是不是也很相似呢？
 

与调用Object#wait和Object#notifyAll必须处于synchronized修饰的代码中一样（获取Monitor），调用Condition#await和Condition#signalAll的前提是要先获取锁。但不同的是，使用Condition前，需要先通过锁去创建Condition。
 

以ReentrantLock中提供的Condition为例，首先是创建Condition对象：
 

 

Java
 

复制代码
 

ReentrantLock lock = new ReentrantLock(); Condition condition = lock.newCondition(); 
 

然后是获取锁并调用await方法：
 

 

Java
 

复制代码
 

new Thread(() -> { lock.lock(); try { condition.await(); } catch (InterruptedException e) { throw new RuntimeException(e); } lock.unlock(); } 
 

最后，通过调用singalAll唤醒全部阻塞中的线程：
 

 

Java
 

复制代码
 

new Thread(() -> { lock.lock(); condition.signalAll(); lock.unlock(); } 
 

ConditionObject的源码分析
 

作为接口Condition非常惨，因为在Java中只有AQS中的内部类ConditionObject实现了Condition接口：
 

 

Java
 

复制代码
 

public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable { public class ConditionObject implements Condition, java.io.Serializable { private transient Node firstWaiter; private transient Node lastWaiter; } static final class Node { // 省略 } } 
 

ConditionObject只有两个Node类型的字段，分别是链式结构中的头尾节点，ConditionObject就是通过它们实现的等待队列。那么ConditionObject的等待队列起到了怎样的作用呢？是类似于AQS中的排队机制吗？带着这两个问题，我们正是开始源码的分析。
 

await方法的实现
 

Condition接口中定义了4个线程等待的方法：
 

  • void await() throws InterruptedException
  • void awaitUninterruptibly();
  • long awaitNanos(long nanosTimeout) throws InterruptedException;
  • boolean await(long time, TimeUnit unit) throws InterruptedException;
  • boolean awaitUntil(Date deadline) throws InterruptedException;
 

方法虽然很多，但它们之间的差异较小，只体现在时间的处理上，我们看其中最常用的方法：
 

 

Java
 

复制代码
 

public final void await() throws InterruptedException { // 线程中断，抛出异常 if (Thread.interrupted()) { throw new InterruptedException(); } // 注释1：加入到Condition的等待队列中 Node node = addConditionWaiter(); // 注释2：释放持有锁（调用AQS的release） int savedState = fullyRelease(node); int interruptMode = 0; // 注释3：判断是否在AQS的等待队列中 while (!isOnSyncQueue(node)) { LockSupport.park(this); // 中断时退出方法 if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) { break; } } // 加入到AQS的等待队列中，调用AQS的acquireQueued方法 if (acquireQueued(node, savedState) && interruptMode != THROW_IE) { interruptMode = REINTERRUPT; } // 断开与Condition队列的联系 if (node.nextWaiter != null) { unlinkCancelledWaiters(); } if (interruptMode != 0) { reportInterruptAfterWait(interruptMode); } } 
 

注释1的部分，调用addConditionWaiter方法添加到Condition队列中：
 

 

Java
 

复制代码
 

private Node addConditionWaiter() { // 判断当前线程是否为持有锁的线程 if (!isHeldExclusively()) { throw new IllegalMonitorStateException(); } // 获取Condition队列的尾节点 Node t = lastWaiter; // 断开不再位于Condition队列的节点 if (t != null && t.waitStatus != Node.CONDITION) { unlinkCancelledWaiters(); t = lastWaiter; } // 创建Node.CONDITION模式的Node节点 Node node = new Node(Node.CONDITION); if (t == null) { // 队列为空的场景，将node设置为头节点 firstWaiter = node; } else { // 队列不为空的场景，将node添加到尾节点的后继节点上 t.nextWaiter = node; } // 更新尾节点 lastWaiter = node; return node; } 
 

可以看到，Condition的队列是一个朴实无华的双向链表，每次调用addConditionWaiter方法，都会加入到Condition队列的尾部。
 

注释2的部分，释放线程持有的锁，同时移出AQS的队列，内部调用了AQS的release方法：
 

 

Java
 

复制代码
 

=final int fullyRelease(Node node) { try { int savedState = getState(); if (release(savedState)) { return savedState; } throw new IllegalMonitorStateException(); } catch (Throwable t) { node.waitStatus = Node.CANCELLED; throw t; } } 
 

因为已经分析过AQS的release方法和ReentrantLock实现的tryRelease方法，这里我们就不过多赘述了。
 

注释3的部分，isOnSyncQueue判断当前线程是否在AQS的等待队列中，我们来看此时存在的情况：
 

  • 如果isOnSyncQueue返回false，即线程不在AQS的队列中，进入自旋，调用LockSupport#park暂停线程；
  • 如果isOnSyncQueue返回true，即线程在AQS的队列中，不进入自旋，执行后续逻辑。
 

结合注释1和注释2的部分，Condition#await的实现原理了就很清晰了：
 

  • Condition与AQS分别维护了一个等待队列，而且是互斥的，即同一个节点只会出现在一个队列中；
  • 当调用Condition#await时，将线程添加到Condition的队列中（注释1），同时从AQS队列中移出（注释2）；
  • 接着判断线程位于的队列： 
  
    • 位于Condition队列中，该线程需要被暂停，调用LockSupport#park；
    • 位于AQS队列中，该线程正在等待获取锁。
 

基于以上的结论，我们已经能够猜到唤醒方法Condition#signalAll的原理了：
 

  • 将线程从Condition队列中移出，并添加到AQS的队列中；
  • 调用LockSupport.unpark唤醒线程。
 

至于这个猜想是否正确，我们接着来看唤醒方法的实现。
 

Tips：如果忘记了AQS中相关方法是如何实现的，可以回顾下《AQS的今生，构建出JUC的基础》。
 

signal和signalAll方法的实现
 

来看signal和signalAll的源码：
 

 

Java
 

复制代码
 

// 唤醒一个处于等待中的线程 public final void signal() { if (!isHeldExclusively()) { throw new IllegalMonitorStateException(); } // 获取Condition队列中的第一个节点 Node first = firstWaiter; if (first != null) { // 唤醒第一个节点 doSignal(first); } } // 唤醒全部处于等待中的线程 public final void signalAll() { if (!isHeldExclusively()){ throw new IllegalMonitorStateException(); } Node first = firstWaiter; if (first != null) { // 唤醒所有节点 doSignalAll(first); } } 
 

两个方法唯一的差别在于头节点不为空的场景下，是调用doSignal唤醒一个线程还是调用doSignalAll唤醒所有线程：
 

 

Java
 

复制代码
 

private void doSignal(Node first) { do { // 更新头节点 if ( (firstWaiter = first.nextWaiter) == null) { // 无后继节点的场景 lastWaiter = null; } // 断开节点的连接 first.nextWaiter = null; // 唤醒头节点 } while (!transferForSignal(first) && (first = firstWaiter) != null); } private void doSignalAll(Node first) { // 将Condition的队列置为空 lastWaiter = firstWaiter = null; do { // 断开链接 Node next = first.nextWaiter; first.nextWaiter = null; // 唤醒当前头节点 transferForSignal(first); // 更新头节点 first = next; } while (first != null); } 
 

可以看到，无论是doSignal还是doSignalAll都只是将节点移出Condition队列，而真正起到唤醒作用的是transferForSignal方法，从方法名可以看到该方法是通过“转移”进行唤醒的，我们来看源码：
 

 

Java
 

复制代码
 

final boolean transferForSignal(Node node) { // 通过CAS替换node的状态 // 如果替换失败，说明node不处于Node.CONDITION状态，不需要唤醒 if (!node.compareAndSetWaitStatus(Node.CONDITION, 0)) { return false; } // 将节点添加到AQS的队列的队尾 // 并返回老队尾节点，即node的前驱节点 Node p = enq(node); int ws = p.waitStatus; // 对前驱节点状态的判断 if (ws > 0 || !p.compareAndSetWaitStatus(ws, Node.SIGNAL)) { LockSupport.unpark(node.thread); } return true; } 
 

transferForSignal方法中，调用enq方法将node重新添加到AQS的队列中，并返回node的前驱节点，随后对前驱节点的状态进行判断：
 

  • 当ws>0ws > 0ws>0时，前驱节点处于Node.CANCELLED状态，前驱节点退出锁的争抢，node可以直接被唤醒；
  • 当ws≤0ws \leq 0ws≤0时，通过CAS修改前驱节点的状态为Node.SIGNAL，设置失败时，直接唤醒node。
 

《AQS的今生，构建出JUC的基础》中介绍了waitStatus的5种状态，其中Node.SIGNAL状态表示需要唤醒后继节点。另外，在分析shouldParkAfterFailedAcquire方法的源码时，我们知道在进入AQS的等待队列时，需要将前驱节点的状态更新为Node.SIGNAL。
 

最后来看enq的实现：
 

 

Java
 

复制代码
 

private Node enq(Node node) { for (;;) { // 获取尾节点 Node oldTail = tail; if (oldTail != null) { // 更新当前节点的前驱节点 node.setPrevRelaxed(oldTail); // 更新尾节点 if (compareAndSetTail(oldTail, node)) { oldTail.next = node; // 返回当前节点的前驱节点（即老尾节点） return oldTail; } } else { initializeSyncQueue(); } } } 
 

enq的实现就非常简单了，通过CAS更新AQS的队列尾节点，相当于添加到AQS的队列中，并返回尾节点的前驱节点。好了，唤醒方法的源码到这里就结束了，是不是和我们当初的猜想一模一样呢？
 

图解ConditionObject原理
 

功能上，Condition实现了AQS版Object#wait和Object#notify，用法上也与之相似，需要先获取锁，即需要在lock与unlock之间调用。原理上，简单来说就是线程在AQS的队列和Condition的队列之间的转移。
 

线程t持有锁
 

假设有线程t已经获取了ReentrantLock，线程t1，t2和t3正在AQS的队列中等待，我们可以得到这样的结构：
 

 

线程t执行Condition#await
 

如果线程t中调用了Condition#await方法，线程t进入Condition的等待队列中，线程t1获取ReentrantLock，并从AQS的队列中移出，结构如下：
 

 

线程t1执行Condition#await
 

如果线程t1中也执行了Condition#await方法，同样线程t1进入Condition队列中，线程t2获取到ReentrantLock，结构如下：
 

 

线程t2执行Condition#signal
 

如果线程t2执行了Condition#signal，唤醒Condition队列中的第一个线程，此时结构如下：
 

 

通过上面的流程，我们就可以得到线程是如何在Condition队列与AQS队列中转移的：
 

 

结语
 

关于Condition的内容到这里就结束了，无论是理解，使用还是剖析原理，Condition的难度并不高，只不过大家可能平时用得比较少，因此多少有些陌生。
 

 

作者：王有志
 链接：https://juejin.cn/post/7233785522371936315

                

        

        

        

    

  


    

      

        

            

              
                
                  「已注销」
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
深入浅出学习AQS组件

				
			

			

				

					08-25
				

			

		

		

			
				
 - 2：CONDITION当前节点正处在条件队列中，在条件达成前不能获取锁。  - 3：PROPAGATE当前节点获取到锁的信息需要传递给后继节点，共享锁模式使用该值。  - 0：无节点初始状态。 4. nextWaiter：如果当前节点是共享...

			
		

	



                

              
                



	

		

			

				
					
Java并发工具AQS条件队列Condition实现详解

				
			

			

				

					zhuguang10的博客
				

				

					07-19
					
					1103
					
				

			

		

		

			
				
你是否使用过java并发工具包中的Lock和Condition。本文分析一下JDK是如何实现Condition条件队列的，对你今后的使用或许有帮助。如果你觉得分析源码太累，看不懂，可以通过阅读本文以大致了解java显式锁的实现，保证你面试够用了。

约定：

本文AQS均指java.util.concurrent.locks.AbstractQueuedSynchronizer类。
	本文CAS操...

			
		

	



                


  
              

                


	

		

			

				
					
深入理解AQS的condition队列

					
最新发布

				
			

			

				

					qq_28598323的博客
				

				

					08-21
					
					538
					
				

			

		

		

			
				
上一篇讲了CLH队列，这一篇通过ArrayBlockingQueue的源码来讲以下condition队列

			
		

	





	

		

			

				
					
AQS之Condition条件队列源码解析

				
			

			

				

					m289111782的博客
				

				

					09-27
					
					120
					
				

			

		

		

			
				
Condition条件队列是一个单向链表结构，调用await方法的线程会被阻塞执行，包装成节点并加入链表尾部。线程调用signal其实就是将条件队列节点向阻塞队列转移的过程，无论是否发生中断，节点都会转移到阻塞队列，然后阻塞等待获取锁。await方法是默认响应中断的，条件队列中的线程如果在await期间被中断，会设置中断状态，并在获取锁后抛出异常。而lock方法是不响应中断的，如果希望响应中断可以使用lockInterruptibly。

			
		

	



		

			
		



	

		

			

				
					
Condition中的等待队列跟AQS中的同步队列是什么关系

				
			

			

				

					zhangyazheng123的博客
				

				

					08-05
					
					544
					
				

			

		

		

			
				
描述了conditon中的等待队列跟AQS中的同步队列的关系

			
		

	





	

		

			

				
					
JUC核心类AQS的底层原理

				
			

			

				

					03-02
				

			

		

		

			
				
例如，当线程调用了`Condition`对象的`await`方法时，它会被封装成一个`Node`并加入到单向链表中，进入等待状态，直到被其他线程唤醒。这在诸如`ArrayBlockingQueue`等阻塞队列中非常常见。  #### ReentrantLock与...

			
		

	





	

		

			

				
					
java并发编程：juc、aqs

				
			

			

				

					08-09
				

			

		

		

			
				
此外，AQS还支持条件变量（Condition），每个Condition对应一个单向链表，只有在使用条件变量时才会创建。  3. **核心方法**：AQS提供了几个关键的抽象方法，如`tryAcquire()`和`tryRelease()`用于独占模式的资源...

			
		

	





	

		

			

				
					
深入理解Java中的AQS.docx

				
			

			

				

					06-27
				

			

		

		

			
				
**深入理解Java中的AQS**  AbstractQueuedSynchronizer（AQS）是Java并发编程库（java.util.concurrent）中的核心组件，它为实现锁和同步器提供了基础框架。AQS利用了一个内置的FIFO（先进先出）双端队列来管理线程...

			
		

	





	

		

			

				
					
带你看看Java-AQS同步器 源码解读四 条件队列Condition上

				
			

			

				

					12-21
				

			

		

		

			
				
在AQS中，`Condition`的实现主要依赖于`ConditionObject`类。`await()`方法使当前线程等待，线程会被从同步队列移到条件队列。而`signal()`方法唤醒一个在条件队列等待的线程，将其移回到同步队列，等待获取锁。`...

			
		

	





	

		

			

				
					
Java并发之AQS详解.pdf

				
			

			

				

					08-25
				

			

		

		

			
				
AbstractQueuedSynchronizer（AQS）是 Java 并发编程中的一个核心组件，提供了一套多线程访问共享资源的同步器框架。AQS 定义了两种资源共享方式：Exclusive（独占）和 Share（共享）。在 AQS 中，维护了一个 ...

			
		

	





	

		

			

				
					
Java并发编程解析 | 解析AQS基础同步器的设计与实现

				
			

			

				

					09-08
				

			

		

		

			
				
AQS是Java中解决同步和互斥问题的基础同步器，通过Lock和Condition两个接口来实现管程。Lock用于解决互斥问题，Condition用于解决同步问题。AQS的设计和实现是基于管程技术的，管程是解决同步和互斥问题的有效方法。...

			
		

	





	

		

			

				
					
类似Object监视器方法的Condition接口(详解)

				
			

			

				

					08-30
				

			

		

		

			
				
在`AbstractQueuedSynchronizer`(AQS)中，`Condition`的实现是通过内部类`AbstractQueuedSynchronizer$ConditionObject`完成的。AQS维护了一个同步队列，用于管理等待获取同步状态的线程，而每个`Condition`对象则...

			
		

	





	

		

			

				
					
Java学习资料-详解Condition的await和signal等待/通知机制

				
			

			

				

					06-18
				

			

		

		

			
				
在Java多线程编程中，`Condition`是Java并发包`java.util.concurrent.locks`中的一个接口，它提供了比`Object`类中的`wait()`、`notify()`和`notifyAll()`更加灵活和强大的线程间通信机制。`Condition`与`Lock`配合...

			
		

	





	

		

			

				
					
Alibaba技术大牛丢给我一份Spring Cloud笔记，在GitHub的热度居然高达81

				
			

			

				

					2401_83329718的博客
				

				

					05-03
					
					415
					
				

			

		

		

			
				
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

			
		

	





	

		

			

				
					
AQS源码解析 4.Condition条件队列入门_手写BrokingQueue

				
			

			

				

					How many ten years in the life time?
				

				

					11-23
					
					372
					
				

			

		

		

			
				
Condition 条件队列介绍
AQS 中还有另一个非常重要的内部类 ConditionObject，它实现了 Condition 接口，主要用于实现条件锁。
ConditionObject 中也维护了一个队列，这个队列主要用于等待条件的成立，当条件成立时，其它线程将 signal 这个队列中的元素，将其移动到 AQS 的队列中，等待占有锁的线程释放锁后被唤醒。
Condition 典型的运用场景是在 BlockingQueue 中的实现，当队列为空时，获取元素的线程阻塞在 notEmpty 条件，将其队

			
		

	





	

		

			

				
					
AQS分析Condition等待队列

				
			

			

				

					weixin_36740435的博客
				

				

					05-31
					
					782
					
				

			

		

		

			
				
AQS是AbstractQueneSynchronizer抽象类

封装了Node节点，Node是AQS的静态内部类，Node节点有两个有参构造方法Node(thread ， node){}创建双向链表AQS队列，Node( thread , int waitstatus){}创建的单向链表，等待队列
封装了ConditionObject，CoditionObject是AQS的内部类，实现了Condition接口
包含属性，head(AQS头节点)、tail（AQS尾节点）、state（）、exclusiv

			
		

	





	

		

			

				
					
Java并发锁深度解析：从AQS到Condition

				
			

			

				

					
				

			

		

		

			
				
"这篇PDF文档主要探讨了Java并发锁的设计与实现，通过对JDK源码的解析，涵盖了AQS（AbstractQueuedSynchronizer）基础同步器、LockSupport工具类、Condition接口、Lock接口、ReadWriteLock接口以及自定义API操作等...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值