写点什么

Java 并发之 Condition 详解,springframework 教程

用户头像
极客good
关注
发布于: 刚刚

readLock.lock();


try {


System.out.println(Thread.currentThread().getName() + "拿到锁了");


System.out.println(Thread.currentThread().getName() + "等待信号");


condition.await();


System.out.println(Thread.currentThread().getName() + "拿到信号");


} catch (Exception e) {


} finally {


readLock.unlock();


}


}


/**


  • 唤起线程


*/


public void conditionSignal() {


readLock.lock();


try {


//睡眠 5s 线程 1 启动


Thread.sleep(5000);


System.out.println(Thread.currentThread().getName() + "拿到锁了");


condition.signal();


System.out.println(Thread.currentThread().getName() + "发出信号");


} catch (Exception e) {


} finally {


//释放锁


readLock.unlock();


}


}


}


执行结果


1 pool-1-thread-1 拿到锁了


2 pool-1-thread-1 等待信号 ---释放锁-线程等待 t1


3 pool-1-thread-2 拿到锁了


4 pool-1-thread-2 发出信号 --- 唤起线程 t2 释放锁


5 pool-1-thread-1 拿到信号---t1 继续执行


如示例所示,


一般都会将 Condition 对象作为成员变量。当调用 await()方法后,当前线程会释放锁并在此等待,而其他线程调用 Condition 对象的 signal()方法,通知当前线程后,当前线程才从 await()方法返回,并且在返回前已经获取了锁。


Condition 接口常用方法


===============


condition 可以通俗的理解为条件队列。当一个线程在调用了 await 方法以后,直到线程等待的某个条件为真的时候才会被唤醒。这种方式为线程提供了更加简单的等待/通知模式。Condition 必须要配合锁一起使用,因为对共享状态变量的访问发生在多线程环境下。一个 Condition 的实例必须与一个 Lock 绑定,因此 Condition 一般都是作为 Lock 的内部实现。


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

  2. boolean await(long time, TimeUnit unit)?:造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态---》是否超时,超时异常

  3. **awaitNanos(


【一线大厂Java面试题解析+核心总结学习笔记+最新架构讲解视频+实战项目源码讲义】
浏览器打开:qq.cn.hn/FTf 免费领取
复制代码


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


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

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

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

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


Condition 接口原理简单解析


=================


Condition 是 AQS 的内部类。每个 Condition 对象都包含一个队列(等待队列)。等待队列是一个 FIFO 的队列,在队列中的每个节点都包含了一个线程引用,该线程就是在 Condition 对象上等待的线程,如果一个线程调用了 Condition.await()方法,那么该线程将会释放锁、构造成节点加入等待队列并进入等待状态。等待队列的基本结构如下所示。



  • 等待队列分为首节点和尾节点。当一个线程调用 Condition.await()方法,将会以当前线程构造节点,并将节点从尾部加入等待队列。

  • 新增节点就是将尾部节点指向新增的节点。节点引用更新本来就是在获取锁以后的操作,所以不需要 CAS 保证。同时也是线程安全的操作。


等待


==


  • 当线程调用了 await 方法以后。线程就作为队列中的一个节点被加入到等待队列中去了。同时会释放锁的拥有。

  • 当从 await 方法返回的时候。一定会获取 condition 相关联的锁。当等待队列中的节点被唤醒的时候,则唤醒节点的线程开始尝试获取同步状态。如果不是通过 其他线程调用 Condition.signal()方法唤醒,而是对等待线程进行中断,则会抛出 InterruptedException 异常信息。通知


调用 Condition 的 signal()方法,将会唤醒在等待队列中等待最长时间的节点(条件队列里的首节点),在唤醒节点前,会将节点移到同步队列中。当前线程加入到等待队列中如图所示:



在调用 signal()方法之前必须先判断是否获取到了锁。接着获取等待队列的首节点,将其移动到同步队列并且利用 LockSupport 唤醒节点中的线程。节点从等待队列移动到同步队列如下图所示:



被唤醒的线程将从 await 方法中的 while 循环中退出。随后加入到同步状态的竞争当中去。成功获取到竞争的线程则会返回到 await 方法之前的状态。


总结


==


  • 调用 await 方法后,将当前线程加入 Condition 等待队列中。当前线程释放锁。否则别的线程就无法拿到锁而发生死锁。自旋(while)挂起,不断检测节点是否在同步队列中了,如果是则尝试获取锁,否则挂起。

  • 当线程被 signal 方法唤醒,被唤醒的线程将从 await()方法中的 while 循环中退出来,然后调用 acquireQueued()方法竞争同步状态。


利用 Condition 实现生产者消费者模式


=====================


public class BoundedQueue {


/**


  • 生产者容器


*/


private LinkedList<Object> buffer;


/**


  • //容器最大值是多少


*/


private int maxSize;


private Lock lock;


/**


  • 满了


*/


private Condition fullCondition;


/**


  • 不满


*/


private Condition notFullCondition;


BoundedQueue(int maxSize) {


this.maxSize = maxSize;


buffer = new LinkedList<Object>();


lock = new ReentrantLock();


fullCondition = lock.newCondition();


notFullCondition = lock.newCondition();


}


/**


  • 生产者

  • @param obj

  • @throws InterruptedException


*/


public void put(Object obj) throws InterruptedException {


//获取锁


lock.lock();

用户头像

极客good

关注

还未添加个人签名 2021.03.18 加入

还未添加个人简介

评论

发布
暂无评论
Java并发之Condition详解,springframework教程