线程间定制化调用通信—— 1 高内聚低耦合的前提下，线程操作资源类 2 判断/干活/通知 3 多线程交互中，必须要防止多线程的虚假唤醒，也即（判断只用while，不能用if）

最新推荐文章于 2022-12-26 22:34:46 发布
最新推荐文章于 2022-12-26 22:34:46 发布
阅读量182 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39368007/article/details/110451466
版权

生产者与消费者模式

一个生产者与一个消费者


题目：现在有两个线程，可以操作初始值为0的一个变量，实现一个线程对该变量加1，另一个线程对该变量减1，这两个线程的操作加一.减一交替，进行10轮，变量的初始值为0
     高内聚低耦合的前提下，线程操作资源类

package com.dym.juc;

class AirConditioner{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        //1.判断
        if(number!=0){
            this.wait();
        }
        //2.干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        //1.判断
        if(number==0){
            this.wait();
        }
        //2.干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
}

//
//题目：现在有两个线程，可以操作初始值为0的一个变量
// 实现一个线程对该变量加1，另一个线程对该变量减1
// 这两个线程的操作加一,减一交替，进行10轮，变量的初始值为0
// 高内聚低耦合的前提下，线程操作资源类
// 判断/干活/通知

public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner=new AirConditioner();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();

    }
}

两个生产者与两个消费者

package com.dym.juc;

class AirConditioner{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        //1.判断
        if(number!=0){
            this.wait();
        }
        //2.干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        //1.判断
        if(number==0){
            this.wait();
        }
        //2.干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
}

//
//题目：现在有两个线程，可以操作初始值为0的一个变量
// 实现一个线程对该变量加1，另一个线程对该变量减1
// 这两个线程的操作加一,减一交替，进行10轮，变量的初始值为0
// 高内聚低耦合的前提下，线程操作资源类
// 判断/干活/通知

public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner=new AirConditioner();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }
}


package com.dym.juc;

class AirConditioner{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        //1.判断
        if(number!=0){
            this.wait();
        }
        //2.干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        //1.判断
        if(number==0){
            this.wait();
        }
        //2.干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
}

//
//题目：现在有两个线程，可以操作初始值为0的一个变量
// 实现一个线程对该变量加1，另一个线程对该变量减1
// 这两个线程的操作加一,减一交替，进行10轮，变量的初始值为0
// 高内聚低耦合的前提下，线程操作资源类
// 判断/干活/通知

public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner=new AirConditioner();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(200);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(300);
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(400);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(500);
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }
}

多线程交互中，必须要防止多线程的虚假唤醒，也即（判断只用while，不能用if）

package com.dym.juc;

class AirConditioner{
    private int number=0;
    public synchronized void increment() throws InterruptedException {
        //1.判断
        while (number!=0){
            this.wait();
        }
        //2.干活
        number++;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        //1.判断
        while (number==0){
            this.wait();
        }
        //2.干活
        number--;
        System.out.println(Thread.currentThread().getName()+"\t"+number);
        //3.通知
        this.notifyAll();
    }
}

//
//题目：现在有两个线程，可以操作初始值为0的一个变量
// 实现一个线程对该变量加1，另一个线程对该变量减1
// 这两个线程的操作加一,减一交替，进行10轮，变量的初始值为0
// 1  高内聚低耦合的前提下，线程操作资源类
// 2  判断/干活/通知
// 3  多线程交互中，必须要防止多线程的虚假唤醒，也即（判断只用while，不能用if）

public class ThreadWaitNotifyDemo {
    public static void main(String[] args) {
        AirConditioner airConditioner=new AirConditioner();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(200);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(300);
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(400);
                    airConditioner.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 1; i <=10 ; i++) {
                try {
                    Thread.sleep(500);
                    airConditioner.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }
}

小草dym
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jpeek:Java代码静态指标（内聚，耦合等）
05-23
项目建筑师： jPeek是Java代码指标的静态收集器。 动机：例如，类凝聚力被视为最重要的面向对象软件属性之一。 到目前为止，已经发明了30多种不同的内聚度指标，但是几乎没有一个具有可用的计算器。 其他指标的情况非常相似。 我们希望创建一个这样的工具，使它或多或少地正式分析代码质量（使用数百个指标）成为可能。 然后，我们将这种分析应用于不同的Java库，目的是证明Elegant Objects丛书中的思想是有意义的。 如何使用？ 从此处加载最新的jar-with-dependencies.jar文件，然后： $ java -jar jpeek-jar-with-dependencies.jar --sources . --target ./jpeek jPeek将分析当前目录中的Java文件。 XML报告将在./jpeek目录中生成。 享受。 您还可以将其作为Web服务部
嵌入式系统/ARM技术中的在Windows2000下用多线程实现1394串行总线通信
12-10
作者Email: [email protected]摘 要：基于Windows2000环境开发了1394主控机与1394设备机间进行串行总线通信的软硬件系统，其中采用了多线程技术，并利用临界区实现线程间共享资源的同步，从而有效地解决了串行通信...
3、线程间通信
AldrichEugene
09-08 127
一起学习juc
【JUC并发编程03】线程间通信
为了远大的理想，冲锋！
01-27 1727
文章目录3 线程间通信3.1 synchronized 实现案例3.2 虚假唤醒问题3.3 Lock 实现案例 3 线程间通信 线程间通信有两种实现方法： 关键字 synchronized 与 wait()/notify() 这两个方法一起使用可以实现等待/通知模式 Lock 接口中的 newContition() 方法返回 Condition 对象，Condition 类也可以实现等待/通知模式 用 notify()通知时，JVM 会随机唤醒某个等待的线程 使用 Condition 类可以进行选择性通知
JUC并发编程之线程间通信、线程间定制化通信
maxker的博客
12-26 91
线程之间的通讯：synchronized 实现案例、虚假唤醒问题、Lock 实现案例，线程间定制化通信（单标志法存在的问题）。
Java 并发编程(一)-JUC
杀神lwz的博客
04-02 516
​ 一、概述 JUC就是java.util.concurrent工具包的简称，这是一个处理线程的工具包，JDK1.5开始出现的。 管程：又称Monitor监视器，又是锁：是一种同步的机制，保证同一时间，只有一个线程访问被保护的数据或代码。 用户线程：自定义线程基本都是用户线程。通过Thread.currentThread().isDaemon()来判断是否是用户线程，等于 false是用户线程。等于true 是守护线程。 守护线程：特殊线程，运行在后台，比如：垃圾回收 设置守护线程： 线程.set
C++11/14 线程调用类对象和线程传参的方法
08-26
主要介绍了C++11/14 线程调用类对象和线程传参的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Linux下多线程间通信
09-14
线程间无需特别的手段进行通信，因为线程间可以共享数据结构，也就是一个全局变量可以被两个线程同时使用。不过要注意的是线程间需要做好同步，一般用 mutex。pthread_mutex_lock 声明开始用互斥锁上锁，此后的代码...
Java多线程-线程间的通信
最新发布
02-02
Java多线程--线程间的通信
通信与网络中的基于TCP/IP的多线程通信及其在远程监控系统中的应用
12-07
摘 要： 提出了一种在Windows NT下基于TCP/IP协议的多线程通信的设计与实现方法，在此基础上给出了多线程通信在蓄电池远程监控系统中的应用实例。 关键词： 多线程 实时性 TCP/IP协议 远程监控系统  传统的应用...
JUC学习笔记一：复习多线程操作资源类的方法
qq_31314141的博客
02-04 741
高内聚，低耦合 所谓高内聚，低耦合就是每个程序要实现的特定功能要尽量多的在自己的内部完成，对外部提供很少量的接口以便调用。 并行和并发 并行即多个任务在自己的分配的各自的资源上执行，即多个任务同时跑，互不冲突。 并发即多个任务在统一的一个资源内执行，多个任务会抢占同一资源，在cpu中体现为交替执行，并不能同时执行，但是cpu在多个线程中切换的速度会非常快，所以宏观上看似是同时的。 最大的区别体现在...
JUC之线程抢占资源
张鑫的博客
08-21 556
创建线程重要！！！ 1、怎么做多线程题？口诀：线程 操作  资源类 ，高内聚低耦合(指的是操作) 不管会不会，先创建资源类，在资源类里封装对资源的操作，然后在创建多个线程，在操作这个资源类 2、多线程操作时候，就会产生线程安全问题，比如，之前提过的 i++ 就是线程不安全,JUC提供了安全解决措施，在 java.util.concurrent.locks包下，怎么做到线程安全，就是尽量做到原...
JUC 四 线程间定制通信
零零JA
09-03 133
1，线程间定制通信模板 1、有顺序通知，需要有标识位 2、有一个锁Lock，3把钥匙Condition 3、判断标志位 4、输出线程名+第几次+第几轮 5、修改标志位，通知下一个 2，demo package com.atguigu.thread; import java.util.concurr...
JUC | JUC线程间的通信
蕤荥的成长博客
11-09 216
多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
JUC---线程间定制化通信
myjess’s blog
07-23 208
此博客案例来自尚硅谷JUC视频 一、线程间的通信 实现两个线程（AA、BB），使得AA线程+1，BB线程-1 package com.jess.sync; /** * @program: JUC * @description: 线程间的通信 * @author: Jess * @create: 2021-07-23 13:48 **/ //第一步 创建资源类，定义属性和操作方法 class Share { //初始值 private int number = 0; //.
线程间定制化通信问题
weixin_45417821的博客
07-14 148
文章目录案例分析案例介绍代码实现 案例分析 上图： 案例介绍 问题: A 线程打印 5 次 A，B 线程打印 10 次 B，C 线程打印 15 次 C,按照 此顺序循环 10 轮 代码实现 package com.lock; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; //第一步，
生产者/消费者代码（使用notify和wait实现）
qq_38089964的博客
12-18 485
package cn.wzy.Lock; import java.util.Random; public class ConsumerAndProducer { static String[] food = new String[5]; static String take() throws InterruptedException { synchronized (food) {...
多线程之间的交互编程（虚假唤醒）
WonderKing'blog
04-19 242
结论： 1、高聚低合前提下，线程操作资源类 2、判断/干活/通知 3、多线程交互中，必须要防止多线程的虚假唤醒，也即（判断只用while，不能用if） 题目： 一个空调，两个人，一人关，一人开，交替进行。 package main.test; /** * @Auther: wdq * @Date: 2020/4/19 15:53 * @Description: */...
题目：顺序打印:a打印5次；b打印10次；c打印15次，循环10次
alenejinping的专栏
02-07 209
public class SyncAndReentrantLockDemo { public static void main(String[] args) { final ShareResource shareResource = new ShareResource(); for (int i = 0; i < 11; i++) { } Thread thread = new Thread(new Runnable() { .
多线程规划及线程间通信
11-03
Java多线程是Java语言中非常重要的知识点，它可以帮助我们更好地管理和控制程序的并发执行。在多线程编程中，线程间通信是非常重要的一部分，它可以让不同的线程之间进行数据交换和协作，从而实现更加复杂的任务。线程间通信的方式主要有以下几种： 1.共享变量：多个线程共享同一个变量，通过对变量的读写来进行通信。 2.管道通信：通过管道来进行线程间的通信，一个线程将数据写入管道，另一个线程从管道中读取数据。 3.信号量：通过信号量来进行线程间的通信，一个线程通过信号量发出信号，另一个线程通过信号量接收信号。 4.消息队列：通过消息队列来进行线程间的通信，一个线程将消息写入队列，另一个线程从队列中读取消息。 5.锁机制：通过锁机制来进行线程间的通信，一个线程获取锁之后，另一个线程必须等待锁的释放才能获取锁。 6.条件变量：通过条件变量来进行线程间的通信，一个线程等待某个条件变量满足之后再继续执行，另一个线程通过改变条件变量的值来通知等待的线程。 7.线程池：通过线程池来进行线程间的通信，将任务提交到线程池中，线程池会自动分配线程来执行任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值