多线程之Condition（十五）

最新推荐文章于 2021-08-04 22:37:41 发布
最新推荐文章于 2021-08-04 22:37:41 发布
阅读量101 收藏
点赞数
分类专栏： java之多线程学习笔记 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43861630/article/details/114698469
版权

  1. 关键字synchronized与wait/notify这两个方法一起使用，可以实现等待/通知模式。lock锁的newCondition()方法会返回Condition对象，Condition类也可以实现等待/通知模式。

  2. 使用notify通知时，JVM会随机唤醒某个等待的线程，使用Condition类可以进行选择行通知。Condition比较常用的两个方法：

  1. await()会使当前线程等待，同时会释放锁，当其他线程调用signal()时，线程会重新获得锁行继续执行.
  2. signal()用于唤醒一个等待的线程

注意：
在调用Condition的await/signal方法前，也需要线程持有相关的lock锁，调用await后线程会释放这个锁，在signal调用后会从当前Condition对象的等待队列中，唤醒一个线程，唤醒的线程会尝试获得锁，一旦获得锁成功就会继续执行

一、Condition实现等待与通知

dome


package com.dome.lock.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * Condition 等待与通知
 * @date 2021/3/11 11:20
 */
public class Test01 {

    //定义锁
    static Lock lock = new ReentrantLock();

    //获得Condition对象
    static Condition condition = lock.newCondition();

    //定义线程子类
    static class SubThread extends Thread{
        @Override
        public void run() {
            try {
                lock.lock(); //在调用await方法前先获取锁
                System.out.println("method  lock");
                condition.await();
                System.out.println("method await");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock(); //释放锁
                System.out.println("method unlock");
            }
        }
    }

    public static void main(String[] args) {
        SubThread subThread = new SubThread();
        subThread.start();
        //子线程启动后，会转入等等待状态

        try {
            //主线程睡眠3秒，唤醒子线程
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
            lock.lock();
            condition.signal();
        } finally {
            lock.unlock();
        }

    }

}

在这里插入图片描述

二、使用多个Condition实现通知部分线程

使用更灵活
dome


package com.dome.lock.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * 多个condition通知部分线程
 * @date 2021/3/11 11:29
 */
public class Test02 {

    static class Service{
        //定义锁对象
        private ReentrantLock lock = new ReentrantLock();

        //定义两个Condition对象
        private Condition conditionA = lock.newCondition();
        private Condition conditionB = lock.newCondition();

        //定义方法使conditionA等待
        public void waitMethodA(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+" 开始等待 "+System.currentTimeMillis());
                conditionA.await();
                System.out.println(Thread.currentThread().getName()+"结束等待"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法使conditionB等待
        public void waitMethodB(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+" 开始等待 "+System.currentTimeMillis());
                conditionB.await();
                System.out.println(Thread.currentThread().getName()+"结束等待"+System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法唤醒conditionA的等待
        public void signalA(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() +" signal A time = "+System.currentTimeMillis());
                conditionA.signal();
                System.out.println(Thread.currentThread().getName()+" signal * A time = "+System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

        //定义方法唤醒conditionB的等待
        public void signalB(){
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName() +" signal B time = "+System.currentTimeMillis());
                conditionB.signal();
                System.out.println(Thread.currentThread().getName()+" signal * B time = "+System.currentTimeMillis());
            } finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {

        Service service = new Service();

        //开启两个线程,分别调用
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodA();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                service.waitMethodB();
            }
        }).start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //华兴 A 上的等待
        service.signalA();
    }
}

在这里插入图片描述

三、 使用Condition实现生产者/消费者而设计模式， 两个线程交替打印

dome

package com.dome.lock.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * 使用Condition实现生产者/消费者而设计模式， 两个线程交替打印
 * @date 2021/3/11 11:41
 */
public class Tetst03 {

    static class MyService{
        private Lock lock = new ReentrantLock();  //创建锁对象

        private Condition condition = lock.newCondition(); //创建Condition对象

        private boolean flag = true ; ///定义打印标志

        //定义方法但因 ---横线
        public void printOne(){
            try {
                lock.lock();
                while (flag){ //为ture等待
                    System.out.println(Thread.currentThread().getName()+"wait.....");
                    condition.await();
                }
                System.out.println(Thread.currentThread().getName() + "-------");
                flag = true;
                condition.signal(); //通知另外线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法但因 ***横线
        public void printTwo(){
            try {
                lock.lock();
                while (!flag){ //为false等待
                    System.out.println(Thread.currentThread().getName()+"wait.....");
                    condition.await();
                }
                System.out.println(Thread.currentThread().getName() + "******");
                flag = false;
                condition.signal(); //通知另外线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {

        MyService myService = new MyService();

        //创建线程打印--
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    myService.printOne();
                }
            }
        }).start();

        //创建线程打印**
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    myService.printTwo();
                }
            }
        }).start();

    }
}

在这里插入图片描述

四、Condition实现多对多的生产者消费者模式

dome

package com.dome.lock.condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author qb
 * @version 1.0
 * @Description
 * 使用Condition实现生产者/消费者而设计模式， 多线程交替打印
 * @date 2021/3/11 11:41
 */
public class Tetst04 {

    static class MyService{
        private Lock lock = new ReentrantLock();  //创建锁对象

        private Condition condition = lock.newCondition(); //创建Condition对象

        private boolean flag = true ; ///定义打印标志

        //定义方法但因 ---横线
        public void printOne(){
            try {
                lock.lock();
                while (flag){ //为ture等待
                    System.out.println(Thread.currentThread().getName()+"wait.....");
                    condition.await();
                }
                System.out.println(Thread.currentThread().getName() + "----------");
                flag = true;
                //condition.signal(); //通知另外线程打印
                condition.signalAll(); //通知另外线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        //定义方法但因 ***横线
        public void printTwo(){
            try {
                lock.lock();
                while (!flag){ //为false等待
                    System.out.println(Thread.currentThread().getName()+"wait.....");
                    condition.await();
                }
                System.out.println(Thread.currentThread().getName() + "**********");
                flag = false;
                //condition.signal(); //通知另外线程打印
                condition.signalAll(); //通知另外线程打印
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {

        MyService myService = new MyService();

        for (int i = 0; i < 10; i++) {
            //创建线程打印--
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        myService.printOne();
                    }
                }
            }).start();

            //创建线程打印**
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 100; i++) {
                        myService.printTwo();
                    }
                }
            }).start();
        }
        //结果造成假死  解决 将  signal换成 signalAll

    }
}

在这里插入图片描述

离别又见离别
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中condition使用遇到的问题
qq_30698633的博客
06-07 717
今天在学习java中的condition的时候，遇到一个问题。(最后发现还是基础不行啊~) 在使用condition.await()方法之后，我以为该线程就结束了，剩余的代码不执行了，后来在写demo的时候发现测试结果怎么也不正确，一调试发现condition.await()后面的代码执行了。 所以，await()方法只是让线程停止了执行，并且释放了锁，在使用signal()重新唤醒该线程
多线程小抄集
磊哥聊Java
03-25 191
Java中线程的状态 NEW、RUNNABLE（RUNNING or READY）、BLOCKED、WAITING、TIME_WAITING、TERMINATEDJava将操作系统中的运...
多线程中Condition的用法
qq_44828283的博客
04-09 957
多线程中Condition的用法与Object中wait、notify、notifyAll用法非常的相似 Condition与Lock对象搭配完成等待唤醒机制 首先我们需要创建Condition对象 newCondition();//返回Condition实例 首先我们知道wait、notify使用前提是通过synchronized获取锁对象，而Condition对象也需要在使用前获取锁。此时获取锁是通过Lock的lock()方法获取锁。 Condition能够支持不响应中断，而通过使用Object方式
多线程——Condition的介绍以及用法
你不在我都在的博客
04-10 5532
之前总结了wait和notify的用法，今天总结一下condition的用法。 Condition介绍： 关键字synchronize可以与wait()和nitify()方法相结合实现实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助condition对象。condition类是在JDK5中出现的技术，使用他有更好的灵活性，比如可以实现多路通知功能，也就是在一个Loc...
JAVA多线程(十六)Java多线程之Condition对象
yuan_xw的专栏
01-29 273
1.JAVA多线程(十六)Java多线程之Condition对象 1.1 什么是Condition？    Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较...
java多线程加锁以及Condition类的使用实例解析
08-25
Java 多线程加锁以及 Condition 类的使用实例解析 摘要：本篇文章主要介绍了 Java 多线程加锁机制和 Condition 类的使用实例解析，通过示例代码详细介绍了多线程加锁和 Condition 类的使用方法，对大家的学习或者...
python多线程高级锁condition简单用法示例
09-18
主要介绍了python多线程高级锁condition简单用法,结合实例形式分析了condition对象常用方法及相关使用技巧,需要的朋友可以参考下
Java多线程中ReentrantLock与Condition详解
08-28
Java多线程中ReentrantLock与Condition详解 ReentrantLock是Java多线程中一种高级的锁机制，它实现了Lock接口，提供了与synchronized相同的并发性和内存语义，但添加了一些特性，如锁投票、定时锁等候和可中断锁...
Java多线程编程中使用Condition类操作锁的方法详解
09-02
在Java多线程编程中，Condition类是Java并发包`java.util.concurrent.locks`中的一个核心组件，它提供了比传统`synchronized`关键字更细粒度的锁控制机制。Condition允许我们创建独立的等待集合，这使得线程可以更加...
c++多线程编程的十个例子
08-21
以下是对“C++多线程编程的十个例子”的详细讲解，这些例子将帮助你在Windows环境下深入理解和应用多线程。 1. **创建线程** C++11引入了`std::thread`库来创建和管理线程。例如，你可以通过传递函数或成员函数...
java多线程之Condition的使用
热门推荐
心猿意碼
04-17 1万+
目录 一、Condition的概念 二、Condition的实现分析 （1）等待 （2）通知 三、Condition应用 （1）简单demo （2）可阻塞队列的应用案例 （3）多线程轮流执行 一、Condition的概念 回忆 synchronized 关键字，它配合 Object 的 wait()、notify() 系列方法可以实现等待/通知模式。对于 Lock，通过...
Python 线程条件(Condition),(线程等待另一个线程的执行)
houyanhua1的专栏
10-13 8141
线程1执行（cond），线程1执行一半等待（cond.wait()），线程2开始执行（cond），线程2执行完毕后（cond.notify()），线程1再接着执行。 import threading import time def go1(): with cond: #使用条件变量(资源 Lock) for i in range(8):
java多线程结束通知_Java多线程Condition实现等待/通知
weixin_39715652的博客
02-27 531
Java多线程可以通过synchronzied与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式。通过显式Lock和Condition也可以实现等待/通知模式。因为在使用notify()/notifyAll()方法进行通知时，被通知的线程是由JVM随机选择的。但是通过Lock和Condition可以选择性的通知，更灵活。在condition.await()方法...
java 线程condition_(七)java多线程之Condition
weixin_42101720的博客
02-12 160
引言在写(五)java多线程之Lock类时,我们暂时忽略掉Lock的一个方法,那就是Lock.newCondition(),这个方法返回一个Condition,现在我们这章就重点讲这个东东是什么,以及怎么使用.理论Condition的中文翻译是状态.没错,这个就是让多线程在不同状态切换其他线程执行.跟Object.wait和Object.notify有点类似.Condition.await: 让当...
多线程——Condition的使用
qq_46117170的博客
08-04 391
多线程——Condition的使用 Condition是在java 1.5中才出现的，用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来模拟线程间协作。 Condition是个接口，基本的方法就是await()和signal()方法； Condi
多线程-condition
visoprkx的专栏
05-23 223
https://www.cnblogs.com/yoyoketang/p/8337118.html # coding=utf-8 import threading import time con = threading.Condition() num = 0 # 生产者 class Producer(threading.Thread): def __init__(self...
Java多线程Condition接口原理详解
路漫漫，水迢迢
05-21 1万+
Condition接口提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的 Condition接口详解Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁。Condition对象是由Lock对象（调用Lock对象的newCondition()方法）创建出来的，换句话
多线程之Condition的简介及原理解析（九）
努力+坚持，而且还很年轻
10-16 952
上篇博文，我们重点介绍阻塞队列BlockingQueue，并实现了生产者和消费者模式。这篇博文，我们重点介绍Condition的相关内容，我们会通过两篇博文来介绍Condition。这篇是对Condition的简介，与Object类的等待通知模式简单对比，Condition接口具体实现，以及等待队列原理解析。然后通过源码解读，看具体实现并使用Condition实现生产者和消费者模式。 Condit...
多线程Condition用法
A_Runner的博客
06-10 5221
深知身在情长在，怅望江头江水声 此前，我们知道用synchronized与wait()和notify()/notifyAll()方法结合可以实现等待/通知模式。但是，在使用notify()/notifyAll()方法进行通知时，被通知的线程却是由JVM随机选择的。为了摆脱这种窘境，Java在1.5引入了ReentrantLock和Condition类结合使用来达到有选择性的进行线程通知，在调度线...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值