【死磕Java并发】-----J.U.C之Condition

ConvNeXt 改进 :ConvNeXt添加GnConv递归门控卷积,二次创新CNBlock结构 ,独家首发 视觉 Transformer 在多种任务中取得了显著的成功,这得益于基于点积自注意力的新空间建模机制。视觉 Transformer 中的关键因素——即输入自适应、长距离和高阶空间交互——也可以通过卷积框架高效实现。作者提出了递归门控卷积(Recursive Gated Convolution,简称 gnConv),通过门控卷积和递归设计执行高阶空间交互。该新操作具有高度的灵活性和可定制性,兼容各种卷积变体,并将自注意力中的二阶交互扩展到任意阶数,而不会引入显著的额外计算。 阅读详情

此篇博客所有源码均来自JDK 1.8

在没有Lock之前,我们使用synchronized来控制同步,配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5后,Java提供了Lock接口,相对于Synchronized而言,Lock提供了条件Condition,对线程的等待、唤醒操作更加详细和灵活。下图是Condition与Object的监视器方法的对比(摘自《Java并发编程的艺术》):

Condition提供了一系列的方法来对阻塞和唤醒线程:

  1. await() :造成当前线程在接到信号或被中断之前一直处于等待状态。

  2. **await(long time, TimeUnit unit) **:造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。

  3. **awaitNanos(long nanosTimeout) **:造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。返回值表示剩余时间,如果在nanosTimesout之前唤醒,那么返回值 = nanosTimeout - 消耗时间,如果返回值 <= 0 ,则可以认定它已经超时了。

  4. **awaitUninterruptibly() **:造成当前线程在接到信号之前一直处于等待状态。【注意:该方法对中断不敏感】。

  5. **awaitUntil(Date deadline) **:造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。如果没有到指定时间就被通知,则返回true,否则表示到了指定时间,返回返回false。

  6. signal():唤醒一个等待线程。该线程从等待方法返回前必须获得与Condition相关的锁。

  7. signal()All:唤醒所有等待线程。能够从等待方法返回的线程必须获得与Condition相关的锁。

Condition是一种广义上的条件队列。他为线程提供了一种更为灵活的等待/通知模式,线程在调用await方法后执行挂起操作,直到线程等待的某个条件为真时才会被唤醒。Condition必须要配合锁一起使用,因为对共享状态变量的访问发生在多线程环境下。一个Condition的实例必须与一个Lock绑定,因此Condition一般都是作为Lock的内部实现。


作者:大明哥 原文地址:http://cmsblogs.com/?p=2222

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。

友情提示:欢迎关注公众号【芋道源码】。????关注后,拉你进【源码圈】微信群和【大明哥】搞基嗨皮。


Condtion的实现

获取一个Condition必须要通过Lock的newCondition()方法。该方法定义在接口Lock下面,返回的结果是绑定到此 Lock 实例的新 Condition 实例。Condition为一个接口,其下仅有一个实现类ConditionObject,由于Condition的操作需要获取相关的锁,而AQS则是同步锁的实现基础,所以ConditionObject则定义为AQS的内部类。定义如下:

public class ConditionObject implements Condition, java.io.Serializable {
}

等待队列

每个Condition对象都包含着一个FIFO队列,该队列是Condition对象通知/等待功能的关键。在队列中每一个节点都包含着一个线程引用,该线程就是在该Condition对象上等待的线程。我们看Condition的定义就明白了:

public class ConditionObject implements Condition, java.io.Serializable {
   private static final long serialVersionUID = 1173984872572414699L;

   //头节点
   private transient Node firstWaiter;
   //尾节点
   private transient Node lastWaiter;

   public ConditionObject() {
   }

   /** 省略方法 **/
}

从上面代码可以看出Condition拥有首节点(firstWaiter),尾节点(lastWaiter)。当前线程调用await()方法,将会以当前线程构造成一个节点(Node),并将节点加入到该队列的尾部。结构如下:

Node里面包含了当前线程的引用。Node定义与AQS的CLH同步队列的节点使用的都是同一个类(AbstractQueuedSynchronized.Node静态内部类)。

Condition的队列结构比CLH同步队列的结构简单些,新增过程较为简单只需要将原尾节点的nextWaiter指向新增节点,然后更新lastWaiter即可。

等待

调用Condition的await()方法会使当前线程进入等待状态,同时会加入到Condition等待队列同时释放锁。当从await()方法返回时,当前线程一定是获取了Condition相关连的锁。

    public final void await() throws InterruptedException {
       // 当前线程中断
       if (Thread.interrupted())
           throw new InterruptedException();
       //当前线程加入等待队列
       Node node = addConditionWaiter();
       //释放锁
       long savedState = fullyRelease(node);
       int interruptMode = 0;
       /**
        * 检测此节点的线程是否在同步队上,如果不在,则说明该线程还不具备竞争锁的资格,则继续等待
        * 直到检测到此节点在同步队列上
        */
       while (!isOnSyncQueue(node)) {
           //线程挂起
           LockSupport.park(this);
           //如果已经中断了,则退出
           if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
               break;
       }
       //竞争同步状态
       if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
           interruptMode = REINTERRUPT;
       //清理下条件队列中的不是在等待条件的节点
       if (node.nextWaiter != null) // clean up if cancelled
           unlinkCancelledWaiters();
       if (interruptMode != 0)
           reportInterruptAfterWait(interruptMode);
   }

此段代码的逻辑是:首先将当前线程新建一个节点同时加入到条件队列中,然后释放当前线程持有的同步状态。然后则是不断检测该节点代表的线程释放出现在CLH同步队列中(收到signal信号之后就会在AQS队列中检测到),如果不存在则一直挂起,否则参与竞争同步状态。

加入条件队列(addConditionWaiter())源码如下:

    private Node addConditionWaiter() {
       Node t = lastWaiter;    //尾节点
       //Node的节点状态如果不为CONDITION,则表示该节点不处于等待状态,需要清除节点
       if (t != null && t.waitStatus != Node.CONDITION) {
           //清除条件队列中所有状态不为Condition的节点
           unlinkCancelledWaiters();
           t = lastWaiter;
       }
       //当前线程新建节点,状态CONDITION
       Node node = new Node(Thread.currentThread(), Node.CONDITION);
       /**
        * 将该节点加入到条件队列中最后一个位置
        */
       if (t == null)
           firstWaiter = node;
       else
           t.nextWaiter = node;
       lastWaiter = node;
       return node;
   }

该方法主要是将当前线程加入到Condition条件队列中。当然在加入到尾节点之前会清楚所有状态不为Condition的节点。

fullyRelease(Node node),负责释放该线程持有的锁。

    final long fullyRelease(Node node) {
       boolean failed = true;
       try {
           //节点状态--其实就是持有锁的数量
           long savedState = getState();
           //释放锁
           if (release(savedState)) {
               failed = false;
               return savedState;
           } else {
               throw new IllegalMonitorStateException();
           }
       } finally {
           if (failed)
               node.waitStatus = Node.CANCELLED;
       }
   }

isOnSyncQueue(Node node):如果一个节点刚开始在条件队列上,现在在同步队列上获取锁则返回true

    final boolean isOnSyncQueue(Node node) {
       //状态为Condition,获取前驱节点为null,返回false
       if (node.waitStatus == Node.CONDITION || node.prev == null)
           return false;
       //后继节点不为null,肯定在CLH同步队列中
       if (node.next != null)
           return true;

       return findNodeFromTail(node);
   }

unlinkCancelledWaiters():负责将条件队列中状态不为Condition的节点删除

        private void unlinkCancelledWaiters() {
           Node t = firstWaiter;
           Node trail = null;
           while (t != null) {
               Node next = t.nextWaiter;
               if (t.waitStatus != Node.CONDITION) {
                   t.nextWaiter = null;
                   if (trail == null)
                       firstWaiter = next;
                   else
                       trail.nextWaiter = next;
                   if (next == null)
                       lastWaiter = trail;
               }
               else
                   trail = t;
               t = next;
           }
       }

通知

调用Condition的signal()方法,将会唤醒在等待队列中等待最长时间的节点(条件队列里的首节点),在唤醒节点前,会将节点移到CLH同步队列中。

    public final void signal() {
       //检测当前线程是否为拥有锁的独
       if (!isHeldExclusively())
           throw new IllegalMonitorStateException();
       //头节点,唤醒条件队列中的第一个节点
       Node first = firstWaiter;
       if (first != null)
           doSignal(first);    //唤醒
   }

该方法首先会判断当前线程是否已经获得了锁,这是前置条件。然后唤醒条件队列中的头节点。

doSignal(Node first):唤醒头节点

    private void doSignal(Node first) {
       do {
           //修改头结点,完成旧头结点的移出工作
           if ( (firstWaiter = first.nextWaiter) == null)
               lastWaiter = null;
           first.nextWaiter = null;
       } while (!transferForSignal(first) &&
               (first = firstWaiter) != null);
   }

doSignal(Node first)主要是做两件事:1.修改头节点,2.调用transferForSignal(Node first) 方法将节点移动到CLH同步队列中。transferForSignal(Node first)源码如下:

     final boolean transferForSignal(Node node) {
       //将该节点从状态CONDITION改变为初始状态0,
       if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
           return false;

       //将节点加入到syn队列中去,返回的是syn队列中node节点前面的一个节点
       Node p = enq(node);
       int ws = p.waitStatus;
       //如果结点p的状态为cancel 或者修改waitStatus失败,则直接唤醒
       if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
           LockSupport.unpark(node.thread);
       return true;
   }

整个通知的流程如下:

  1. 判断当前线程是否已经获取了锁,如果没有获取则直接抛出异常,因为获取锁为通知的前置条件。

  2. 如果线程已经获取了锁,则将唤醒条件队列的首节点

  3. 唤醒首节点是先将条件队列中的头节点移出,然后调用AQS的enq(Node node)方法将其安全地移到CLH同步队列中

  4. 最后判断如果该节点的同步状态是否为Cancel,或者修改状态为Signal失败时,则直接调用LockSupport唤醒该节点的线程。

总结

一个线程获取锁后,通过调用Condition的await()方法,会将当前线程先加入到条件队列中,然后释放锁,最后通过isOnSyncQueue(Node node)方法不断自检看节点是否已经在CLH同步队列了,如果是则尝试获取锁,否则一直挂起。当线程调用signal()方法后,程序首先检查当前线程是否获取了锁,然后通过doSignal(Node first)方法唤醒CLH同步队列的首节点。被唤醒的线程,将从await()方法中的while循环中退出来,然后调用acquireQueued()方法竞争同步状态。

Condition的应用

只知道原理,如果不知道使用那就坑爹了,下面是用Condition实现的生产者消费者问题:

public class ConditionTest {
   private LinkedList<String> buffer;    //容器
   private int maxSize ;           //容器最大
   private Lock lock;
   private Condition fullCondition;
   private Condition notFullCondition;

   ConditionTest(int maxSize){
       this.maxSize = maxSize;
       buffer = new LinkedList<String>();
       lock = new ReentrantLock();
       fullCondition = lock.newCondition();
       notFullCondition = lock.newCondition();
   }

   public void set(String string) throws InterruptedException {
       lock.lock();    //获取锁
       try {
           while (maxSize == buffer.size()){
               notFullCondition.await();       //满了,添加的线程进入等待状态
           }

           buffer.add(string);
           fullCondition.signal();
       } finally {
           lock.unlock();      //记得释放锁
       }
   }

   public String get() throws InterruptedException {
       String string;
       lock.lock();
       try {
           while (buffer.size() == 0){
               fullCondition.await();
           }
           string = buffer.poll();
           notFullCondition.signal();
       } finally {
           lock.unlock();
       }
       return string;
   }
}
Cesium中级开发教程之二十二:视锥体 教程示例网站:https://thomaz529.github.io。 阅读详情

相关推荐

PLC编程入门基础知识

PLC即为可编程逻辑控制器,实质是一种专用于工业控制的计算机,其硬件结构基本上与微型计算机相同。

SANRENYIXING的博客 2万+

Condition 源码解读

通过上面的源码分析,应该对Condition有了新的理解和掌握,细心地小伙伴应该可以发现在源码中好多地方都使用了CAS,因此当竞争资源非常激烈时,Lock的性能要远远优于。

小毕超博客 854

解决/usr/lib64/libstdc++.so.6和/lib64/libc.so.6版本过低问题

在CentOS7.0中编译好MySQL5.7.14之后,然后在CentOS6.5中初始化MySQL,执行:/usr/local/mysql/bin/mysqld --version出现如下问题:./bin/mysqld: /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.15' not found (required by ./bin/mysqld)

poxiaonie的博客 2万+

Condition源码解析

java Condition源码解析

隔壁老杨的专栏 468

保姆级教程:在RK3576上配置USB网卡从零到外网访问(附udev规则详解)

本文提供了在RK3576开发板上配置USB网卡的完整教程,涵盖从内核驱动、udev规则到网络路由的全流程。重点讲解了如何利用USB Gadget功能实现高速网络连接,并构建稳定的算力集群,确保多设备间通信及外网访问。

grass的博客 461

在Qt中使用EtherCAT-SOEM的初始化中,状态机卡在PreOp->Save-Op过程中,出现State=0x12, Error=0x001e错误的解决办法

1.在调试EtherCAT软件过程中,一直出现配置从站进不了Save_op状态,通过下函数检查从站状态: //使用的从站编号为1 只有1个从站 ec_slave[1].state = EC_STATE_SAFE_OP; ec_writestate(1); //设置到安全模式 ec_statecheck(1, EC_STATE_SAFE_OP, EC_TIMEOUTSTATE * 4); printf("Slave %d State=0x%2.2x StatusCode=0x%4

zeal_for_rov的博客 6830

Condition源码分析

基于jdk1.8进行分析的。 之前有写到AQS和ReentrantLock源码分析,当然少不了的就是分析一下Condition。 通过源码来看是一个接口。下面我们看看这个接口定义的方法。 public interface Condition { //造成当前线程在接到信号或被中断之前一直处于等待状态 void await() throws InterruptedExcepti...

Burgess_Lee的博客 183

【红外DDE算法】一种应用于高动态范围红外可视化的算法

【红外DDE算法】一种应用于高动态范围红外可视化的算法 - 这个算法背后的动机 - 展示这个算法的流程 - 然后讨论各个可调参数的意义。

sunwindl91181的博客 1683

【并发编程】Condition源码分析

Condition源码分析,从等待队列迁移到AQS同步队列

qq_35448165的博客 466

使用Matlab实现海洋监视雷达检测仿真

海洋监视雷达是一项重要的海洋探测技术,可以用于海上船只、飞机、潜艇等目标的探测和监视,具有广泛的应用价值。本篇文章将介绍如何使用Matlab进行海洋监视雷达的检测仿真,并提供相应的源代码。本篇文章提供了利用Matlab进行海洋监视雷达检测仿真的基本思路和代码实现。读者可以根据自己的需求进行修改和优化,以适应不同的应用场景。使用Matlab实现海洋监视雷达检测仿真。

2301_78484069的博客 450

【立创EDA-PCB设计基础】6.布线铺铜实战及细节详解

本文进行布线铺铜实战及详解布线铺铜的细节

嵌入式阿齐Archie 4万+

【死磕Java并发】—–J.U.C之Condition

原文出处:http://cmsblogs.com/ 『chenssy』 此篇博客所有源码均来自JDK 1.8 在没有Lock之前,我们使用synchronized来控制同步,配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5后,Java提供了Lock接口,相对于Synchronized而言,Lock提供了条件Condition,对线程的等待、唤醒...

Elon Zero的博客 309

18 中望CAD二次开发-DWG参照(ZRX C++)

本文介绍了CAD参考外部dwg文件的原理和代码实现及如何卸载参考文件的全过程,是中望CAD二次开发中重要的功能。

cilvsuanna的博客 208

java condition_死磕Java并发:J.U.C之Condition

在没有Lock之前,我们使用synchronized来控制同步,配合Object的wait()、notify()系列方法可以实现等待/通知模式。在Java SE5后,Java提供了Lock接口,相对于Synchronized而言,Lock提供了条件Condition,对线程的等待、唤醒操作更加详细和灵活。下图是Condition与Object的监视器方法的对比(摘自《Java并发编程的艺术》):C...

weixin_39616216的博客 66

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

死磕Java并发:J.U.C之Condition

作者:chenssy 来源:http://cmsblogs.com/?p=2222在没有Lock之前,我们使用synchronized来控制同步,配合Object的wai...

程序猿DD 646

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

死磕 Java 并发

作者 :大明哥 博客 :http://cmsblogs.com/?cat=151 目录 : 《【死磕 Java 并发】—– 深入分析 synchronized 的实现原理》 《【死磕 Java 并发】—– 深入分析 volatile 的实现原理》 《【死磕 Java 并发】—– Java 内存模型之 happens-before》 《【死磕 Java 并发】—– Java 内存模...

scofen的博客 787

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

【死磕Java并发】—–J.U.C之阻塞队列:LinkedBlockingDeque

Table of Contents LinkedBlockingDeque 基础方法 前面的BlockingQueue都是单向的FIFO队列,而LinkedBlockingDeque则是一个由链表组成的双向阻塞队列,双向队列就意味着可以从对头、对尾两端插入和移除元素,同样意味着LinkedBlockingDeque支持FIFO、FILO两种操作方式。 LinkedBlockingDeque...

Elon Zero的博客 199

【死磕Java并发】—–J.U.C之阻塞队列:DelayQueue

Table of Contents DelayQueue Delayed 内部结构 offer() take() DelayQueue是一个支持延时获取元素的无界阻塞队列。里面的元素全部都是“可延期”的元素,列头的元素是最先“到期”的元素,如果队列里面没有元素到期,是不能从列头获取元素的,哪怕有元素也不行。也就是说只有在延迟期到时才能够从队列中取元素。 DelayQueue主要用于两...

Elon Zero的博客 169

【死磕Java并发】—–J.U.C之并发工具类:CyclicBarrier

Table of Contents 实现分析 应用场景 应用示例 CyclicBarrier,一个同步辅助类,在API中是这么介绍的: 它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称...

Elon Zero的博客 182

【死磕Java并发】—–J.U.C之AQS:AQS简介

AQS工作原理概要 AbstractQueuedSynchronizer又称为队列同步器(后面简称AQS),它是用来构建锁或其他同步组件的基础框架,AQS的主要使用方式是继承,子类通过继承同步器并实现它的抽象方法来管理同步状态。 内部通过一个int类型的成员变量state来控制同步状态,当state=0时,则说明没有任何线程占有共享资源的锁,当state=1时,则说明有线程目前正在使用共享变量...

Elon Zero的博客 247

【死磕Java并发】—–J.U.C之阻塞队列:ArrayBlockingQueue

ArrayBlockingQueue,一个由数组实现的有界阻塞队列。该队列采用FIFO的原则对元素进行排序添加的。 ArrayBlockingQueue为有界且固定,其大小在构造时由构造函数来决定,确认之后就不能再改变了。ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略,但是在默认情况下不保证线程公平的访问,在构造时可以选择公平策略(fair = tr...

Elon Zero的博客 140

java c 并发_【死磕Java并发】-J.U.C之并发工具类:CyclicBarrier - Java 技术驿站-Java 技术驿站...

此篇博客所有源码均来自JDK 1.8CyclicBarrier,一个同步辅助类,在API中是这么介绍的:它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。通俗点讲就是...

weixin_36197581的博客 145

死磕Java并发:J.U.C之AQS:CLH同步队列

本文转载自公号:Java技术驿站在上篇文章“死磕Java并发:J.U.C之AQS简介”中提到了AQS内部维护着一个FIFO队列,该队列就是CLH同步队列。CLH同步队列是...

程序猿DD 722

【死磕Java并发】-----J.U.C之阻塞队列:ArrayBlockingQueue

原文出处http://cmsblogs.com/ 『chenssy』 ArrayBlockingQueue,一个由数组实现的有界阻塞队列。该队列采用FIFO的原则对元素进行排序添加的。ArrayBlockingQueue为有界且固定,其大小在构造时由构造函数来决定,确认之后就不能再改变了。ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略,但是在默认情况下不

chenssy 的技术博客 7238
上一篇: 数据库中间件 MyCAT源码分析:【单库单表】插入
下一篇: Dubbo源码解析 —— 逻辑层设计之服务降级
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值