【并发编程】线程间的通信

已于 2023-05-14 11:12:22 修改
阅读量285 收藏 9
点赞数 7
分类专栏： # JUC专栏 文章标签： java 后端
于 2022-11-11 09:56:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47533244/article/details/127800625
版权

文章目录

1.wait、notify、notifyAll
  • 在多线程环境下，有时候一个线程的执行，依赖于另一个线程的某种状态的改变，这时就可以使用wait和notify或者notifyAll。
  • wait和sleep的区别：wait会释放持有的锁，但是sleep不会，sleep知识让线程在指定的时间内，不去抢占cpu的资源。
  • wait notify在使用的时候必须放在同步代码块里，必须拥有当前对象的锁，不能获取A对象的锁，去唤醒B对象。
  • notify随机唤醒一个等待的线程，notifyAll唤醒所有在该对象上等待的线程。
public class WaitDemo {

    private static boolean flag = false;

    private static Object object = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (object) {
                if (!flag) {
                    try {
                        System.out.println("flag is false");
                        System.out.println(object+"进入等待状态");
                        object.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("flag is true");
        }).start();

        Thread.sleep(2000L);
        new Thread(() -> {
            synchronized (object) {
                flag = true;
                object.notify();
                System.out.println(object+"被唤醒");
            }
        }).start();
    }

}

在这里插入图片描述

2.生产者消费者模型

（1）生产者消费者模型图

在这里插入图片描述

（2）编码实战

  • 中间商Broker代码
public class Broker {

    //当前库存数
    private static int num;

    //规定最大库存数量
    private static final int TOTAL = 20;

    /**
     * 生产者生产产品存入库存
     */
    public synchronized void put(){
        //先判断库存有没有满
        if(num < TOTAL){
            //库存没有满时，生产者生产
            System.out.println("---库存新增一个，当前库存为："+ ++num);
            //唤醒消费者消费
            notifyAll();
        }else{
            try {
                //库存满时，生产这进入等待状态
                System.out.println("***库存已满，生产者等待生产");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 消费者消费库存
     */
    public synchronized void take(){
        //先判断是否有库存
        if(num>0){
            System.out.println("---库存减少1个，当前库存为："+ --num);
            //唤醒生产者
            notifyAll();
        }else{
            try {
                System.out.println("***暂无库存，消费者等待消费");
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
  • 生产者Producer代码
public class Producer implements Runnable {

    private Broker broker;

    public Producer(Broker broker) {
        this.broker = broker;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("###生产者生产一件商品");
            broker.put();
        }
    }
}
  • 消费者Consumer代码
public class Consumer implements Runnable {

    private Broker broker;

    public Consumer(Broker broker) {
        this.broker = broker;
    }

    @Override
    public void run() {
        while (true) {
            System.out.println("###消费者消费一件商品");
            broker.take();
        }
    }
}
  • 测试代码
public static void main(String[] args) {

    //创建中间商
    Broker broker = new Broker();

    //生产者线程
    for (int i = 0; i < 5; i++) {
        new Thread(new Producer(broker)).start();
    }

    //消费者线程
    for (int i = 0; i < 5; i++) {
        new Thread(new Consumer(broker)).start();
    }
}

在这里插入图片描述

3.管道流进行线程间的通信
  • 管道流进行通信其实就是以内存为媒介，一个线程去往里面存数据，一个线程去里面取数据，用于线程间的通信。
  • 主要有两类
    • 面向字节：【PipedOutputStream、PipedInputStream】
    • 面向字符：【PipedReader、PipedWriter】

（1）字节管道流

  • 编写线程ByteStreamReader类
public class ByteStreamReader implements Runnable {

    private PipedInputStream pipedInputStream;

    public ByteStreamReader(PipedInputStream pipedInputStream) {
        this.pipedInputStream = pipedInputStream;
    }

    @Override
    public void run() {
        try {
            if(pipedInputStream != null){
                //读取内存中中的数据
                String str = new BufferedReader(new InputStreamReader(pipedInputStream)).lines().collect(Collectors.joining("\n"));
                System.out.println("当前线程："+Thread.currentThread().getName()+"读取内存中的数据："+str);
            }
            pipedInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 测试代码
public static void main(String[] args) throws IOException {
    //创建管道输入流
    PipedInputStream pipedInputStream = new PipedInputStream();
	//创建管道输出流
    PipedOutputStream pipedOutputStream = new PipedOutputStream();
	//输入流与输出流建立连接
    pipedOutputStream.connect(pipedInputStream);
	//启动线程，将输入流作为参数传输进去
    new Thread(new ByteStreamReader(pipedInputStream)).start();
	//创建字符输入流
    BufferedReader bufferedReader = null;
	
    System.out.print("当前线程："+Thread.currentThread().getName()+"向内存中写入数据：");
	//将控制台输入的内容转化成流
    bufferedReader = new BufferedReader(new InputStreamReader(System.in));
	//写入内存
    pipedOutputStream.write(bufferedReader.readLine().getBytes());
	
    pipedOutputStream.close();

    if(bufferedReader != null){
        bufferedReader.close();
     }
}

在这里插入图片描述

  • 注意：不要在同一个线程中使用PipInputStream和PipOutputStream，会造成死锁。
4.Thread.join()方法

（1）join()方法简介

  • join()方法一共三个方法重载
public final void join() throws InterruptedException;

public final synchronized void join(long millis) throws InterruptedException;

public final synchronized void join(long millis, int nanos) throws InterruptedException;
  • 三个重载最终都掉用一个参数的版本。
  • join()和join(0)是等价的，表示会一直等下去，join(非0)表示等待一段时间。
  • 使用场景：线程A执行到一半，需要一个数据，这个数据需要线程B去执行修改，只有B修改完成之后，A才能继续操作。

（2）join的使用

public class JoinDemo {

    public static int num = 0;

    public void add() {
        num++;
    }

    public static void main(String[] args) {
        JoinDemo joinDemo = new JoinDemo();

        Thread thread = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + ":开始执行");
            System.out.println(Thread.currentThread().getName() + ":执行num+1");
            joinDemo.add();
            System.out.println(Thread.currentThread().getName() + ":结束执行");
        }, "线程1");

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + ":开始执行");
                thread.start();
                /**join方法控制让线程2中的线程1先执行完成以后在执行线程2后面的操作*/
                thread.join();
                if (num == 1) {
                    System.out.println(Thread.currentThread().getName() + ":拿到的num为：" + num);
                }
                System.out.println(Thread.currentThread().getName() + ":结束执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "线程2").start();
    }
}
  • 没有加上join()方法的运行结果

在这里插入图片描述

  • 加上join()方法的运行结果

在这里插入图片描述

5.Condition详解

（1）Condition简介

  • 在线程Thread类中线程之间通信是通过object类的wait()和notify()方式实现的。而ReentrantLock也有类似于wait()和notify()功能。前者是java底层级别后者是语言级别的具有更高的可控制性和扩展性。
  • 二者的区别：
    • Condition能够支持不响应式中断，而通过使用Object方式不支持。
    • Condition能偶支持多个等待队列（new多个Condition对像），而Object方式只能支持一个。
    • Condition能够支持超时时间的设置，而Object不支持。

（2）案例实战

  • 简单案例
public class ConditionDemo implements Runnable{
    private static Lock lock = new ReentrantLock();

    private static Condition condition = lock.newCondition();

    @Override
    public void run() {
        try{
            lock.lock();
            condition.await();
            System.out.println("Thread is going on");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ConditionDemo());
		//启动线程
        thread.start();
		//睡眠2s
        Thread.sleep(2000);
		//加锁，因为condition在调用await()方法时，会释放锁资源，所以要重新加锁
        lock.lock();
		//唤醒
        condition.signal();
		//解锁
        lock.unlock();
    }
}

在这里插入图片描述

​ 新建的线程thread调用start()方法后执行run()方法，此时掉用lock.lock()方法进行加锁，此时线程获得锁，继续执行condition.await()方法，这个时候线程会释放刚才获得的锁资源，将线程加入到condition维护的等待队列中，等调用condition.signal()方法后，会唤醒condition等待对类中的一个线程加入到AQS对列中去，直至唤醒的线程重新获取所资源后才能继续向下执行。

  • 生产者消费者模型
public class ConditionDemo {

    private int queueSize=10;

    //定义优先队列，大小初始化为10
    private PriorityQueue<Integer> queue = new PriorityQueue<>(queueSize);

    //定义ReentrantLock，Condition要配合锁使用
    private Lock lock = new ReentrantLock();

    //定义生产者的Condition对象
    private Condition producer = lock.newCondition();

    //定义消费者的Condition对象
    private Condition consumer = lock.newCondition();

    class Consumer extends Thread{

        volatile boolean flag = true;

        private void consume(){
            //循环调用
            while(flag){
                //加锁
                lock.lock();
                try{
                    /**
                     * 如果队列是空就让消费者停止消费，进入等待状态，循环等待，
                     * 保证不会在有消费者线程去执行await()方法
                     */
                    while(queue.isEmpty()){
                        try{
                            System.out.println("队列空，等待数据");
                            consumer.await();
                        } catch (InterruptedException e) {
                            //发生异常结束方法执行
                            flag=false;
                        }
                    }
                    //队列弹出一个元素
                    queue.poll();
                    //唤醒生产者
                    producer.signal();
                    System.out.println("从队列中取走一个元素，队列剩余"+queue.size()+"个元素");
                }finally {
                    //最后一定要进行解锁操作
                    lock.unlock();
                }
            }
        }

        @Override
        public void run() {
            consume();
        }
    }

    class Producer extends Thread{

        volatile boolean flag = true;

        private void produce(){
            //循环调用
            while(flag){
                //加锁
                lock.lock();
                try{
                    /**
                     * 判断队列是否已满，如果队列的大小等于规定好的队列长度
                     * 就让生产者进行等待
                     */
                    while(queue.size() == queueSize){
                        try {
                            System.out.println("队列满，等待有空余空间");
                            producer.await();
                        }catch (InterruptedException e){
                            //发生异常结束方法执行
                            flag=false;
                        }
                    }
                    //生产一个元素
                    queue.offer(1); //每次插入一个元素
                    //唤醒消费者
                    consumer.signal();
                    System.out.println("向队列中插入一个元素，队列剩余"+queue.size()+"个元素");
                }finally {
                    lock.unlock();
                }
            }
        }

        @Override
        public void run() {
            produce();
        }
    }

    public static void main(String[] args) {
        ConditionDemo conditionDemo = new ConditionDemo();
        Producer producer = conditionDemo.new Producer();
        Consumer consumer = conditionDemo.new Consumer();
        producer.start();
        consumer.start();
        producer.interrupt();
        consumer.interrupt();
    }
}

在这里插入图片描述

互联网小阿祥
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
线程的创建与线程间通信（C语言）
weixin_56187542的博客
08-09 3752
摘要：线程是如何创建的，线程之间的通信是如何做到的，线程之间通信需要注意什么，线程的同步与互斥是如何使用临界资源的，今天，又是我们一起努力学习的一天，一起来看看。
线程间的通信实例
一丁的博客
12-04 723
线程间的通信主要针对主线程和次线程来说。而线程间的同步是针对两个或多个次线程来说的。 一般而言，应用程序中的一个次要线程总是为主线程执行特定的任务，这样，主线程和次要线程间必定有一个信息传递的渠道，也就是主线程和次要线程间要进行通信。这样线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。一般可以使用全局变量进行通信和自定义消息进行通信。 1.使用全局变量进行通信 由于属于同一...
Qt线程间通信-自定义事件
IT1995的博客
07-15 4879
线程间通信：1.自定义事件：postEvent()；2.信号与槽【本质也是通过自定义事件实现的】注意：每个线程都有自己的事件循环自定义事件： 1.从QEvent继承； 2.registerEventType()； //会返回全局唯一的事件类型 3.QCoreApplication::postEvent()；//异步方式发送事件，Qt本身接管事件周期，在事件处理后就会销毁他，所以new了后不要del...
实现线程通信
qq_58000391的博客
06-07 293
线程通信什么？我们该怎么实现线程通信呢？
C#中使用事件机制实现线程间的通信
qq_38350514的博客
08-10 1444
在图形界面中的运用程序中，通常是主线程负责UI人机交互，而将需要循环执行和耗资源的逻辑代码和复杂的业务实现以及数据交互放到单独一个线程里运行。这样可以保证主线程UI可以正常进行人机交互。 而线程之间的数据交互，就涉及了线程通信。这里将通过一个给MCU升级固件程序的IAP（在应用编程）的一个用C#写的上位机软件的实现原理，来说明如何通过事件的机制来实现线程之间的通信。 关于事件和委托的概念 事...
Java并发编程线程间通讯实现过程详解
08-19
主要介绍了Java并发编程线程间通讯实现过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java并发编程：线程基础
08-09
本资源致力于向您介绍 Java 并发编程中的线程基础，涵盖了多线程编程的核心概念、线程的创建和管理，以及线程间通信的基本方法。通过深入学习，您将建立扎实的多线程编程基础，能够更好地理解和应用多线程编程。 多...
【并发编程】 — 线程间的通信wait、notify、notifyAll
12-21
三个线程顺序打印问题2.1.1 题目2.1.2 题目分析2.1.3 我的答案2.2 生产者消费者问题2.2.1 题目2.2.2 题目分析2.2.3 我的答案 源码地址：https://github.com/nieandsun/concurrent-study.git 1 wait、notify、...
《深入理解 Rust 并发编程》
02-26
线程和线程池： Rust 中线程的创建、管理和同步，包括使用 std::thread 创建线程、线程间的通信以及线程池的构建和使用。特别强调了线程池的重要性，如 rayon 和 crossbeam 提供的线程池，它们能够提高资源利用率和...
Python多进程并发与多线程并发编程实例总结
12-25
多线程并发则由程序员管理并发处理的任务，这种并发方式可以方便地在线程间共享数据（前提是不能互斥）。Python对多线程和多进程的支持都比一般编程语言更高级，最小化了需要我们完成的工作。 一.多进程并发 Mark ...
线程间通信 - 多线程编程（一）
生活需要深度
08-13 777
当锁被占用时试图对其加锁的线程都进入阻塞状态(释放CPU资源使其由运行状态进入等待状态)。自旋锁上锁受阻时线程不阻塞而是在循环中轮询查看能否获得该锁，没有线程的切换因而没有切换开销，不过对CPU的霸占会导致CPU资源的浪费。当以写模式加锁而处于写状态时任何试图加锁的线程(不论是读或写)都阻塞，当以读状态模式加锁而处于读状态时“读”线程不阻塞，“写”线程阻塞。读模式共享，写模式互斥。对条件的测试是在互斥锁的保护下进行的。线程间的通信目的主要是用于线程同步，所以线程没有像进程通信中的用于数据交换的通信机制。..
java高并发处理，限制同一接口访问次数
renkai721的专栏
10-15 7821
第一种实现方式 1、首先在打开拦截器，拦截访问的接口。 package com.zh.config; import java.nio.charset.Charset; import java.util.List; import org.springframework.context.annotation.Bean; import org.springframework.context....
获取webservice 返回soap数据中的body
短腿姑娘的博客
02-26 2010
import javax.xml.soap.*; import java.io.ByteArrayInputStream; import java.io.StringReader; import java.util.Iterator; public class Main { private static int tickets=15; String str = new String(" "); public static void main(String[] args) { /
BufferedReader的readLine方法阻塞的处理
热门推荐
侠之大者，为国为民
06-15 3万+
BufferReader的read方法和readLine方法在任何情况下都是阻塞的。readLine方法每次读一行，相对于一个字符/字节地读取、转换、返回来说，它有一个缓冲区，读满缓冲区才返回；一般情况下，都建议使用它们把其它Reader/InputStream包起来，使得读取数据更高效；对于文件来说，经常遇到一行一行的，特别符合情景。        如果不指定buffer大小，则readLin
记一次Java中BufferReader类readLine()的Debug
zxjm2的博客
11-28 929
记一次Dubug–关于BufferedReader readLine() 先说BUG出现在哪里 最近在做计算机网络的结课设计，选题是一个简易的Web Server，我选择用Java实现。 运行之后，访问Server的主页，页面正常返回，但是会在console上输出一个奇异的null！？ 很明显有线程没有正确的运行完所有代码，中途遇到差错没有完成HTTP的这次通信。 如果是小规模的并发，在个人电脑上...
string模拟实现
最新发布
m0_73969414的博客
04-23 1187
c++中string的模拟实现，面试必会知识点
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 924
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
多线程规划及线程间通信
11-03
Java多线程是Java语言中非常重要的知识点，它可以帮助我们更好地管理和控制程序的并发执行。在多线程编程中，线程间通信是非常重要的一部分，它可以让不同的线程之间进行数据交换和协作，从而实现更加复杂的任务。线程间通信的方式主要有以下几种： 1.共享变量：多个线程共享同一个变量，通过对变量的读写来进行通信。 2.管道通信：通过管道来进行线程间的通信，一个线程将数据写入管道，另一个线程从管道中读取数据。 3.信号量：通过信号量来进行线程间的通信，一个线程通过信号量发出信号，另一个线程通过信号量接收信号。 4.消息队列：通过消息队列来进行线程间的通信，一个线程将消息写入队列，另一个线程从队列中读取消息。 5.锁机制：通过锁机制来进行线程间的通信，一个线程获取锁之后，另一个线程必须等待锁的释放才能获取锁。 6.条件变量：通过条件变量来进行线程间的通信，一个线程等待某个条件变量满足之后再继续执行，另一个线程通过改变条件变量的值来通知等待的线程。 7.线程池：通过线程池来进行线程间的通信，将任务提交到线程池中，线程池会自动分配线程来执行任务。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

互联网小阿祥

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

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

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

打赏作者

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

抵扣说明：

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

余额充值