09-Condition实现精准通知唤醒

已于 2022-09-18 18:30:14 修改
阅读量292 收藏
点赞数
分类专栏： JUC编程 文章标签： java 开发语言
于 2022-08-14 20:30:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43658218/article/details/126335718
版权 
package com.hkx.pc;

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

/**
 * @program: juc
 * @description: 09-Condition实现精准通知唤醒
 * @author: Casey Hu
 * @create: 2022-08-14 19:51
 **/

/**
 * A执行完，调用B。B执行完，调用C。C执行完，调用A。
 */
public class C {
    public static void main(String[] args) {
        Data3 data3=new Data3();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i=0;i<10;i++){
                data3.printC();
            }
        },"C").start();
    }
}
class Data3{

    private Lock lock=new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num=1;
    public void printA(){
        lock.lock();
        try {
            //业务——>判断——>执行——>通知
            while(1!=num){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            num=2;
            //唤醒指定的人 B
            condition2.signal();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
            //业务——>判断——>执行——>通知
            while (2!=num){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            num=3;
            //唤醒指定的人 C
            condition3.signal();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            //业务——>判断——>执行——>通知
            while(num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            num=1;
            //唤醒指定的人 A
            condition1.signal();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            lock.unlock();
        }
    }
}

上面的代码主要设置了多个监视器，随时唤醒指定的线程。
购物场景：在下单完成之后，调用支付操作，在支付完成之后调用交易完成页面，在交易完成之后调用物流操作

5、8锁现象

如何判断锁是谁，永远知道什么是锁，锁到底锁的是谁！
深刻理解锁是什么

package com.hkx.lock8;

/**
 * @program: juc
 * @description:
 * @author: Casey Hu
 * @create: 2022-08-21 20:14
 **/

import java.util.concurrent.TimeUnit;

/***
 *
 *8锁，就是关于锁的8个问题
 * 1、在标准情况下，两个线程是先打印哪个呢？ 1发短信 2打电话
 * 2、发短信的方法延迟四秒，两个线程是先打印哪个呢？ 1发短信 2打电话
 */

public class Test1 {
    public static void main(String[] args) {
        Phone phone=new Phone();
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    //被synchronized修饰的方法，锁的是方法的调用者
    //两个方法用的是同一把锁phone的锁，哪个方法先拿到就先执行哪个
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}



package com.hkx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description:
 * @author: Casey Hu
 * @create: 2022-08-21 21:15
 **/

/**
 * 3、曾加了一个普通方法，是先执行发短信还是执行hello？  hello 发短信 1秒钟输出hello，四秒中说出发短信
 * 4、两个对象，都执行同步方法  是先执行哪个？
 */
public class Test2  {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁
        Phone2 phone1=new Phone2();
        Phone2 phone2=new Phone2();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone2{
    //被synchronized修饰的方法，锁的是方法的调用者
    //两个方法用的是同一把锁phone的锁，哪个方法先拿到就先执行哪个
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //没有锁，不受锁的影响
    public void hello(){
        System.out.println("hello");
    }
}

package com.hkx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description:
 * @author: Casey Hu
 * @create: 2022-08-21 21:32
 **/

/***
 * 5.增加两个静态同步方法，只有一个对象，是先打印哪个？ 发短信 打电话
 * 6、两个对象，增加两个静态同步方法，是先打印哪个？ 发短信 打电话
 */

public class Test3  {
    public static void main(String[] args) {
        //两个对象，锁的模板只有一个，
        Phone3 phone1 =new Phone3();
        Phone3 phone2 =new Phone3();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//5、Phone3 只有唯一 的Class对象，static锁的是class
//6、两个对象，增加两个同步方法，是先打印，还是先发短信，打电话。
class Phone3{
    //被synchronized修饰的方法，锁的是方法的调用者
    //static 静态方法，在类一加载就有了！ Class 模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

package com.hkx.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description:
 * @author: Casey Hu
 * @create: 2022-08-21 21:51
 **/

/**
 * 7、一个对象，一个静态同步方法，一个普通同步方法，是先打印哪个？ 打电话 发短信
 * 7、两个对象，一个静态同步方法，一个普通同步方法，是先打印哪个？ 打电话 发短信
 */
public class Test4  {
    public static void main(String[] args) {
        //两个对象，锁的模板只有一个，
        Phone4 phone1 =new Phone4();
        Phone4 phone2 =new Phone4();
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
//5、Phone3 只有唯一 的Class对象，static锁的是class
//6、两个对象，增加两个同步方法，是先打印，还是先发短信，打电话。
class Phone4{
    //static 静态方法，在类一加载就有了！锁的是Class 模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("发短信");
    }
    //被synchronized修饰的方法，锁的是方法的调用者
    public  synchronized void call(){
        System.out.println("打电话");
    }
}

小结

到底锁，锁的是啥？ new出来的，static修饰的
new this 具体的一个
static Class 唯一的一个模板

6、集合类不安全

List

package com.hkx.unsafe;
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
/**
 * @program: juc
 * @description: 集合类不安全_List
 * @author: Casey Hu
 * @create: 2022-09-18 17:39
 **/
// java.util.ConcurrentModificationException 并发修改异常
public class ListTest {
    public static void main(String[] args) {
        //并发下 ArrayList 是不安全的
        /**
         * 解决方案：
         * 1.List<String> list = new Vector<>();
         * 2.由于ArrayList 不安全，我们选择使用工具类的转化，让ArrayList 变得安全
         * List<String> list = Collections.synchronizedList(new ArrayList<>());
         * 3.List<String> list =new   CopyOnWriteArrayList<String>();
         * CopyOnWrite 写入时候复制 COW 是计算机程序设计领域的一直优化策略
         *多个线程调用的时候，比如唯一的list 在读取的时候是固定的，写入的时候会出现，覆盖的情况
         * 在写的入的时候避免覆盖造成数据问题，造成数据问题
         * 注意：CopyOnWriteArrayList 比 Vector 强在哪？
         * 就是在 CopyOnWriteArrayList 没有 synchronized 修饰采用的 是复制一份在重新赋值的逻辑
         * Vector 里有synchronized 修饰 效率会很低
         */
//        List<String> list = new Vector<>();
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        List<String> list =new   CopyOnWriteArrayList<String>();
        for (int i=1;i<=10;i++){
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();
        }
    }
}
Casey·Hu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Light-Condition-Style-Transfer:使用高效数据增强功能在弱光条件下进行车道检测
03-08
光照条件样式转换纸到2020年IEEE智能车辆专题讨论会（IV 2020）接受。 主要框架如下： 根据经验，使用我们的方法训练的车道检测模型证明了在弱光条件下的适应性以及在复杂场景下的鲁棒性。 （在CULane测试装置中可以...
JUC版的生产者和消费者问题
zhangqiang180的博客
03-30 161
synchronized 和lock 对比 代码实现： public class B { public static void main(String[] args) { Data2 data2 = new Data2(); new Thread(()->{ for(int i=0;i<10;i++){ ...
condition精准唤醒
code_mzh的博客
09-13 245
package JUC.condition; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author HuangHaiyang * @date 2020/07/02 * @description: description * @version: 1.0.0
使用Condition实现精准唤醒线程
weixin_49050715的博客
07-14 551
这里写目录标题Condition简要介绍Condition里的主要方法使用Condition的DemoCondition简要介绍Condition里的主要方法使用Condition的Demo Condition简要介绍 Condition里的主要方法 使用Condition的Demo Condition简要介绍 Condition是一个接口，创建Condition的实例不能直接new，Java为我们提供一个通过Lock类实例来调用newCondition()的方法来创建。Condition因素出Object
Condition精准唤醒和通知
欢迎一起学习交流
04-15 3061
关键字synchornized可以使用wait()和notify()方法实现等待/通知模式，在类ReentrantLock中也可以实现相同的功能，但需要借助java.util.concurrent.locks 下的Condition对象。 使用Condition比synchornized拥有更好的灵活性，它可以在一个Lock对象中创建多个实例，线程对象可以在指定的Condition对象中选择性的进行线程通知，在下线程调度上更为灵活 在使用wait()和no...
8、JUC:Condition实现精准通知唤醒
Garry
11-20 249
学习过程观看视频：[狂神说Java] https://www.bilibili.com/video/BV1B7411L7tE?p=9 欢迎大家支持噢，很良心的老师了！ java代码 package com.zjl; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Creat
five-bells-condition:加密条件验证和实现JavaScript实现
05-06
针对Node.js和浏览器JavaScript中的加密条件实现 规格 编辑草稿： 该规范在此阶段仅是草稿，尚未提交。 目录 创建PREIMAGE-SHA-256填充（哈希码） 解析实现 创建ED25519条件 满足ED25519的条件 验证执行情况...
air-condition-ui:用CodeSandbox创建
05-23
空调用户界面用CodeSandbox创建使用React JS开发应用程序的第二阶段，该阶段作为空调控制的用户界面提供。
summ-numbers-by-condition
06-21
按条件求和对数组中大于 100 的数字求和 实现 sumOnly100Plus 函数，该函数以数组为参数，返回数组中所有大于 100 的数字之和。 数组不仅可以包含数值数据，可以以任何方式忽略它。 工作示例： sumOnly100Plus ([150...
race-condition-example
04-27
种族条件示例 只是一个简单的竞赛条件示例。
Condition实现精准通知唤醒
LIAO_YUANLONG的博客
12-17 99
三个线程用三个不同的监视器监视，来达到我们实现精准通知和唤醒 还是记住Lock锁的三步曲：判断等待，业务，通知 package com.liao.lesson1; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class Test04 { public stati
Condition实现精准的通知和唤醒线程
qq_43712538的博客
07-08 556
如何精准通知和唤醒线程? 通过重复新建Condition监视器,通过在资源类中进行一个if的判断,如果不等于numbername就 condition.await()否则的话就通过new出的监听器来唤醒另个一个线程.思路很简单,是基于上一篇文章. package com.xnizhi; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurren
Condition实现精确通知唤醒
jj89929665的博客
01-21 114
Condition实现精确通知唤醒 package JUC; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * Copyright © 2021 eSunny Info. Tech Ltd. All rights reserved. * * 功能描述： * @P
Condition 实现精准通知唤醒
zhangqiang180的博客
06-05 707
精确通知顺序访问 package juc; //多线程之间按顺序调用 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class C { public static void main(String[] args) { Data3 data =ne
Condition监视器实现精准唤醒，且不需要标识符
aimerary的博客
04-29 143
参考了很多网上的资料和视频，发现Condition监视器的精准唤醒例子都需要使用标识符，但实际上使用标识符的话是可以不用到Condition监视器的直接用Object监视器（wait/notify）来执行的。 个人感觉这些例子举得都不好，所以自己写了不用标识符的情况下可以直接用Condition来实现精准唤醒的例子，也从中发现了一些问题，具体已经写在注释。 public class TestJUC05 { public static void main(String[] args) throws I
Condition实现精准通知和唤醒线程
最新发布
不积跬步无以至千里
08-31 106
这篇文章，衔接多线程中线程协作，引出Condition在原有的Lock锁基础上实现精准通知和唤醒线程。完成需求中提到的，A线程执行完调用B，B执行完调用C，C执行完调用A。需求：A线程执行完调用B，B执行完调用C，C执行完调用A。请耐心读完下面的代码，会让你彻底学会精准通知和唤醒线程！
使用ReenTrantLock+Condition实现精准唤醒线程
我怀念的
05-18 1356
以前我们wait/notify notifyAll来实现线程的等待唤醒机制，可是notify 并不能精准地帮我唤醒我们想要唤醒的那个进程，这是可以使用ReenTrantLock+Condition来实现精准唤醒一个线程，每一个线程都会有一个Condition对象对唤醒。 直接上代码： package com.richinfo.cn.reentrantlock; /** * @author ...
【JUC并发编程】用Condition实现精准唤醒/理解八锁现象
b1ngsha的博客
04-12 187
此时先打印打电话，因为static是静态方法，在静态方法中synchronized锁锁的是Phone的Class模版，由于Phone的Class模版全局唯一，所以两线程共用一把锁，发信息线程先获得锁，所以先执行。此时先打印打电话，再打印发信息，因为sendMessage方法中的锁锁的是Class类模版，call方法中的锁锁的是调用者，因此是两把不同的锁。此时先打印打电话，后打印发信息，因为有两个不同的对象，所以有两个调用者，即两把锁，由于sendMessage方法中存在延时，所以先打印打电话。
unexpected constant condition no-constant-condition
03-16
意思是：意外的常量条件，无常量条件。 这个错误通常出现在程序中使用了一个常量作为条件表达式，例如 if (1) 或 while (true)，这样的条件表达式永远不会改变结果，因此编译器会提示这个错误。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Casey·Hu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值