显式锁(四)Lock的等待通知机制Condition

?? 任意一个Java对象,都拥有一组监视器方法(定义在根类Object上),主要包括:wait( )、wait(long timeout)、notify()、notifyAll()方法;这些方法与关键字synchronized结合使用,可以实现 隐式锁的等待/通知机制。而显示锁Lock也实现了等待/通知机制;Condition接口也提供了类似Object的监视器方法,与Lock配合使用可以实现 显式锁的等待/通知机制,但是两者在使用方式和功能特性有所差别。总得来说,Condition接口更加灵活,功能更多:

  • Condition 接口是支持多个等待队列,也称为条件队列,即根据不同的条件进入不同的等待队列,相应的,用户便可以只在指定的等待队列上唤醒线程,而不是唤醒所有的线程。而 Object监视器 则只能有一个等待队列。
  • Condition 接口还提供了对中断不敏感的等待方法,即当处于等待状态时,是不会被中断的。而Object监视器 不支持不可中断的等待。
  • Condition 接口除了提供了超时等待方法之外,还提供了等待直到将来某个时间段的方法;Object监视器只有超时等待的方法。

Condition 接口的方法:

方法名称 描 述
void await() throws InterruptedException 造成当前线程在接到通知或被中断之前一直处于等待状态。即发生以下两种情况,将会从await()方法返回:
1、其他某个线程调用此 Condition 的 signal()、signalAll()方法;
2、其他某个线程中断当前线程
void awaitUninterruptibly() 造成当前线程在接到通知之前一直处于等待状态。 与await()方法相比,这是不可中断的等待方法
long awaitNanos(long nanosTimeout) throws InterruptedException 造成当前线程在接到通知、被中断或到达指定等待时间之前一直处于等待状态。
返回值:此方法返回时,距离超时的剩余时间,即返回值就是(nanosTimeout - 实际耗时);如果返回值是0或者负数,那么认定已经超时
boolean await(long time, TimeUnit unit) throws InterruptedException 造成当前线程在接到通知、被中断或到达指定等待时间之前一直处于等待状态。
返回值:如果在从此方法返回前检测到等待时间超时(到达指定时间),则返回 false,否则返回 true
此方法在行为上等效于: awaitNanos(unit.toNanos(time)) > 0
boolean awaitUntil(Date deadline) throws InterruptedException 造成当前线程在接到通知、被中断或到达指定最后期限之前一直处于等待状态。
返回值:如果在从此方法返回前检测到等待时间超时(到达指定时间),则返回 false,否则返回 true
void signal() 唤醒一个等待线程。如果所有的线程都在等待此条件,则选择其中的一个唤醒。在从 await 返回之前,该线程必须重新获取锁。
void signalAll() 唤醒所有等待线程。 如果所有的线程都在等待此条件,则唤醒所有线程。在从 await 返回之前,每个线程都必须重新获取锁。


@ Example Condition 的例子

public class BoundedQueue<T> {
    private Object[] item;
    //添加的下标、删除的下标、数组的当前数量
    private int addIndex,removeIndex,count;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BoundedQueue(int size){
        item = new Object[size];
    }

    //添加一个元素,如果数组满,则添加线程进入等待状态,直到有空位
    public void add(T t) throws InterruptedException{
        lock.lock();
        try{
            while(count == item.length){
                //可中断的等待,如果没有剩余空间,那么就进入notFull的等待队列
                notFull.wait();
            }
            item[addIndex] = t;
            if(++addIndex == item.length){//模拟环数组,一直插入,直到尾部,又重新从头部插入
                addIndex = 0;
            }
            count++;
            //刚插入一个元素,不为空的条件满足,可唤醒等待在notEmpty队列上的线程
            notEmpty.signal();
        }finally {
            lock.unlock();
        }
    }

    //从头部移除一个元素,如果数组为空,则等待,直到数组不为空
    public T remove(){
        lock.lock();
        try{
            while(count == 0){
                //不可中断的等待,不为空的条件不满足,就会一直等待
                notEmpty.awaitUninterruptibly();;
            }
            Object x = item[removeIndex];
            if(++removeIndex == item.length){
                removeIndex = 0;
            }
            count--;
            //刚移除一个元素,数组没有满的条件符合,唤醒等待在notFull上的线程
            notFull.signal();
            return (T)x;
        }finally{
            lock.unlock();
        }
    }
}

原文地址:https://www.cnblogs.com/jinggod/p/8491259.html

时间: 2024-10-09 20:10:29

显式锁(四)Lock的等待通知机制Condition的相关文章

ReentrantLock等待通知机制Condition介绍

Object类中的wait(),notify()和notifyAll()可以实现线程的等待通知模型,同样在ReentrantLock中可以借助Condition来完成这种机制.本篇就简要介绍Condition的工作原理. 先看一下Condition的使用示例: public class LockConditionTest { private ReentrantLock lock = new ReentrantLock(); private Condition condition = lock.n

并发编程—4显式锁 Lock

目录 4.显式锁 Lock 4.1 概念 内置锁 vs 显示锁 可重入锁 vs 不可重入锁 公平锁 vs 非公平锁 读锁 vs 写锁 4.2 ReentrantLock源码解读 4.显式锁 Lock 4.1 概念 内置锁 vs 显示锁 synchronize是java语言层面实现的锁,称为内置锁.使用方便代码简洁,而且在jdk新版本优化后,性能也得到了很大的提高.synchronize是一个可重入锁.而Lock是jdk提供开发者是用的一个显式锁.通过lock()和unlock()方法加锁和释放锁

java之AQS和显式锁

本次内容主要介绍AQS.AQS的设计及使用.ReentrantLock.ReentrantReadWriteLock以及手写一个可重入独占锁 1.什么是AQS? AQS,队列同步器AbstractQueuedSynchronizer的简写,JDK1.5引入的,是用来构建锁或者其他同步组件的基础框架,它使用了一个int成员变量表示同步状态,通过内置的FIFO队列来完成资源获取线程的排队工作.AQS的作者Doug Lea大师期望它能够成为实现大部分同步需求的基础. 2.AQS的设计及其作用 Abst

第13章 显式锁

性能是一个不断变化的指标,如果在昨天的测试基准中发现X比Y更快,那么在今天就可能已经过时了. 在激烈竞争的情况下,在非公平锁的性能高于公平锁的性能的一个原因是:在恢复一个被挂起的线程与该线程真正开始运行之间存在着严重的延迟.假设线程A持有一个锁,并且线程B请求这个锁.由于这个锁已被线程A持有,因此B将被挂起.当A释放锁时,B将被唤醒,因此会再次尝试获取锁.与此同时,如果C也请求这个锁,那么C很可能会在B被完全唤醒之前获得.使用以及释放这个锁.这样的情况是一种“双赢”的局面:B获得锁的时刻并没有推

JDK并发包温故知新系列(五)—— 显式锁与显式条件

显式锁-Lock与ReadWriteLockJDK针对Lock的主要实现是ReentrantLock,ReadWriteLock实现是ReentrantReadWriteLock.本文主要介绍ReentrantLock. ReentrantReadWriteLock两把锁共享一个等待队列,两把锁的状态都由一个原子变量表示,特有的获取锁和释放锁逻辑. ReentrantReadWriteLock的基本原理:读锁的获取,只要求写锁没有被线程持有就可以获取,检查等待队列,逐个唤醒等待读锁线程,遇到等待

Java并发编程系列-(4) 显式锁与AQS

4 显示锁和AQS 4.1 Lock接口 核心方法 Java在java.util.concurrent.locks包中提供了一系列的显示锁类,其中最基础的就是Lock接口,该接口提供了几个常见的锁相关的操作. public interface Lock { void lock(); void lockInterruptibly() throws InterruptedException; boolean tryLock(); boolean tryLock(long time, TimeUnit

内置锁(二)synchronized下的等待通知机制

一.等待/通知机制的简介 线程之间的协作: ??为了完成某个任务,线程之间需要进行协作,采取的方式:中断.互斥,以及互斥上面的线程的挂起.唤醒:如:生成者--消费者模式.或者某个动作完成,可以唤醒下一个线程.管道流已准备等等: 等待/通知机制: ? ?等待/通知机制 是线程之间的协作一种常用的方式之一,在显示锁Lock 和 内置锁synchronized都有对应的实现方式. 等待/通知机制 经典的使用方式,便是在生产者与消费者的模式中使用: 1.生产者负责生产商品,并送到仓库中存储: 2.消费者

12.详解Condition的await和signal等待通知机制

1.Condition简介 任何一个java对象都天然继承于Object类,在线程间实现通信的往往会应用到Object的几个方法,比如wait(),wait(long timeout),wait(long timeout, int nanos)与notify(),notifyAll()几个方法实现等待/通知机制,同样的, 在java Lock体系下依然会有同样的方法实现等待/通知机制.从整体上来看Object的wait和notify/notifyAll是与对象监视器配合完成线程间的等待/通知机制

超强图文|并发编程【等待/通知机制】就是这个feel~

你有一个思想,我有一个思想,我们交换后,一个人就有两个思想 If you can NOT explain it simply, you do NOT understand it well enough 现陆续将Demo代码和技术文章整理在一起 Github实践精选 ,方便大家阅读查看,本文同样收录在此,觉得不错,还请Star 并发编程为什么会有等待通知机制 上一篇文章说明了 Java并发死锁解决思路 , 解决死锁的思路之一就是 破坏请求和保持条件, 所有柜员都要通过唯一的账本管理员一次性拿到所有