三、线程间的通信

最新推荐文章于 2024-04-28 19:05:10 发布
最新推荐文章于 2024-04-28 19:05:10 发布
阅读量125 收藏
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XZQ_STUD/article/details/112052355
版权

多线程 volatile CyclicBarrier 同步 Java
关键词由CSDN通过智能技术生成

下面程序会有什么问题

package examination;

import java.util.ArrayList;
import java.util.List;

/**
 * taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 * @author xzq
 */
public class Examination01 {

    public static void main(String[] args) {
        final Box_1 box=new Box_1();

        new Thread("线程1"){

            @Override
            public void run() {
                try {
                    for(int i=1;i<=10;i++){
                        box.add(new Object());
                        System.out.println("线程1：add第"+i+"个元素");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();


        new Thread("线程2"){

            @Override
            public void run() {
                while(true){
                    if(box.size()==5){
                        break;
                    }
                }
                System.out.println("线程2执行完毕！");
            }
        }.start();
    }

}

/**
 * 这样实现有什么问题？
 * @author xzq
 */
class Box_1{

    private List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述
线程2不会得到通知，不会结束，
线程1不通知我 我自己获取 也可以结束，加入下面代码
在这里插入图片描述
在这里插入图片描述

2、解决问题 为对象添加volatile
private volatile List box=new ArrayList<>();

package examination;


import java.util.ArrayList;
import java.util.List;

/**
 * taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 * @author xzq
 */
public class Examination02 {

    public static void main(String[] args) {
        final Box_2 box=new Box_2();

        new Thread("线程1"){

            @Override
            public void run() {
                try {
                    for(int i=1;i<=10;i++){
                        box.add(new Object());
                        System.out.println("线程1：add第"+i+"个元素");
                        Thread.sleep(1_000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();


        new Thread("线程2"){

            @Override
            public void run() {
                try {
                    while(true){
                        if(box.size()==5){
                            Thread.sleep(2_000);
                            System.out.println("线程2：我看到容器中已经有5个元素啦！！！");
                            break;
                        }
                    }
                    System.out.println("线程2：执行完毕！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

}

/**
 * 加上volatile使box的修改可以得到通知
 * 这样实现有什么问题？
 *
 * 1、由于add和size没有加锁，那么就不具备互斥性，
 * 有可能会出现当线程2判断完size==5后，线程切换了
 * 然后线程1又加了一次已经到6了，然后在切换回线程2
 * 此时，线程2才break，这样就与原逻辑不符。
 *
 * 2、用死循环的方式十分浪费CPU的资源
 * @author xzq
 */
class Box_2{

    private volatile List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述
3、使用wait和notify方法
wait()会释放锁，而nodify()不会释放锁。
线程2wait()后释放了锁 线程1进入，但线程1执行到size=5时nodify()了，但线程2并没有继续执行而是等线程1结束才开始执行 说明nodify()不会释放锁

package examination;

import java.util.ArrayList;
import java.util.List;

/**
 * taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 *
 * 这里使用wait()和notify()方法实现，
 * 注意：wait()会释放锁，而nodify()不会释放锁。
 *
 * 该例中线程2必须比线程1先启动，才能保持监听状态
 * 因为必须先wait，才有nodify。
 *
 * 但是本程序的输出还是没有达到预期效果：
 * size=5的时候线程2没有继续往下执行，而是
 * 等到线程1执行完毕后才往下执行的，因为
 * nodify是不释放锁的，而wait被nodify后是需要
 * 重新持有锁的，但是现在这把锁被线程1持有着
 * 所以只能等到线程1离开同步代码块时，线程2
 * 才能继续往下执行。

 * @author xzq
 */
public class Examination03 {

    public static void main(String[] args) {
        final Box_3 box=new Box_3();
        final Object obj=new Object();

        new Thread("线程2"){

            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        System.out.println("线程2：开始执行");
                        //4秒后线程1才打印 说明4秒后线程2中wait()释放了锁
                        Thread.sleep(4000);
                        if(box.size()!=5){
                            obj.wait();
                        }
                        System.out.println("线程2：执行完毕！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();



        new Thread("线程1"){

            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        System.out.println("线程1：开始执行");
                        for(int i=1;i<=10;i++){
                            box.add(new Object());
                            System.out.println("线程1：add第"+i+"个元素");
                            if(box.size()==5){
                                obj.notify();
                            }
                            Thread.sleep(1_000);
                        }
                        System.out.println("线程1：执行完毕！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}

/**
 * 加上volatile后使box的修改可以得到通知
 *
 * @author Peter
 */
class Box_3{

    private volatile List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述
4、优化wait和notify方法

解决方案：

  • 线程1在nodify后必须要释放锁，那么就得wait了，然后线程2就可以获取到锁
  • 然后线程2被唤醒后也必须再nodify通知线程2，虽然使用nodify唤醒了线程1，但线程2并没有释放锁，要5秒后线程2执行完释放了锁 线程1已才能获取到锁继续添加元素
package examination;

import java.util.ArrayList;
import java.util.List;

/**
 * taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 *
 * 这里使用wait()和notify()方法实现，
 * 注意：wait()会释放锁，而nodify()不会释放锁。
 *
 * 该例中线程2必须比线程1先启动，才能保持监听状态
 * 因为必须先wait，才有nodify。
 *
 * 但是本程序的输出还是没有达到预期效果：
 * size=5的时候线程2没有继续往下执行，而是
 * 等到线程1执行完毕后才往下执行的，因为
 * nodify是不释放锁的，而wait被nodify后是需要
 * 重新持有锁的，但是现在这把锁被线程1持有着
 * 所以只能等到线程1离开同步代码块时，线程2
 * 才能继续往下执行。
 *
 * 解决方案：
 * 线程1在nodify后必须要释放锁，那么就得wait了，
 * 然后线程2被唤醒后也必须再nodify通知线程2。
 * @author xzq
 */
public class Examination04 {

    public static void main(String[] args) {
        final Box_4 box=new Box_4();
        final Object obj=new Object();

        new Thread("线程2"){

            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        System.out.println("线程2：开始执行");
                        if(box.size()!=5){
                            obj.wait();
                        }
                        System.out.println("线程2：执行完毕！");
                        //通知线程2我已经被唤醒了，你也别等着了
                        obj.notify();
                        /*
                         上面notify只是唤醒了线程1，但我并没有释放锁 
                         要5秒后我执行完释放了锁 线程1已才能获取到锁继续添加元素
                         */
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();



        new Thread("线程1"){

            @Override
            public void run() {
                synchronized (obj) {
                    try {
                        System.out.println("线程1：开始执行");
                        for(int i=1;i<=10;i++){
                            box.add(new Object());
                            System.out.println("线程1：add第"+i+"个元素");
                            if(box.size()==5){
                                obj.notify();
                                //释放锁，让线程2得以执行。
                                obj.wait();
                            }
                            Thread.sleep(1_000);
                        }
                        System.out.println("线程1：执行完毕！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

}

/**
 * 加上volatile后使box的修改可以得到通知
 *
 * @author xzq
 */
class Box_4{

    private volatile List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述
5、使用CyclicBarrier方法解决

     只有设置为2的时候才可以满足，设置3就不行
     CyclicBarrier 是篱栅的意思，要等两个线程都执行完才能进行下一步
     await()可以是线程进入barrier(障碍)状态，当两个线程都进入barrier状态时
     两个线程继续执行下面的内容 不需再等待

final CyclicBarrier barrier=new CyclicBarrier(2);
barrier.await();

package examination;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 *
 * 这里使用CountDownLatch/CyclicBarrier/Semaphore
 * 都可以简便解决这个需求
 * @author xzq
 */
public class Examination05 {


    public static void main(String[] args) {
        final Box_5 box=new Box_5();
         /*
         只有设置为2的时候才可以满足，设置3就不行
         CyclicBarrier 是篱栅的意思，要等两个线程都执行完才能进行下一步
         await()可以是线程进入barrier(障碍)状态，当两个线程都进入barrier状态时
         两个线程继续执行下面的内容 不需再等待
         */
        final CyclicBarrier barrier=new CyclicBarrier(2);

        new Thread("线程2"){

            @Override
            public void run() {
                try {
                    System.out.println("线程2：开始执行");
                    if(box.size()!=5){
                        barrier.await();
                    }
                    System.out.println("线程2：执行完毕！");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();



        new Thread("线程1"){

            @Override
            public void run() {
                try {
                    System.out.println("线程1：开始执行");
                    for(int i=1;i<=10;i++){
                        box.add(new Object());
                        System.out.println("线程1：add第"+i+"个元素");
                        if(box.size()==5){
                            barrier.await();
                        }
                        Thread.sleep(1_000);
                    }
                    System.out.println("线程1：执行完毕！");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

}

/**
 * 加上volatile后使box的修改可以得到通知
 *
 * @author xzq
 */
class Box_5{

    private volatile List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述
6、使用Semaphore 信号灯方法

package examination;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;

/**
 *  taobao examination
 * 实现一个容器，提供两个方法，add和size
 * 写两个线程，线程1添加10个元素到容器中，
 * 线程2实现监控元素的个数，当个数到5个时，
 * 线程2给出提示并结束
 *
 * 这里使用CountDownLatch/CyclicBarrier/Semaphore
 * 都可以简便解决这个需求
 * @author xzq
 */
public class Examination06 {


    public static void main(String[] args) {
        final Box_6 box=new Box_6();

        final Semaphore reachSema=new Semaphore(0);


//      final Semaphore addSema=new Semaphore(10);

        final Semaphore addSema=new Semaphore(1);


        new Thread("线程2"){

            @Override
            public void run() {
                try {
                    System.out.println("线程2：开始执行");
                    if(box.size()!=5){
                        reachSema.acquire();
                    }
                    System.out.println("线程2：执行完毕！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();




        new Thread("线程1"){

            @Override
            public void run() {
                try {
                    System.out.println("线程1：开始执行");
                    for(int i=1;i<=10;i++){
                        addSema.acquire();
                        box.add(new Object());
                        System.out.println("线程1：add第"+i+"个元素");
                        if(box.size()==5){
                            reachSema.release();
                        }
                        addSema.release();
                        Thread.sleep(1_000);
                    }
//                      addSema.release();//这里是创建10个信号灯的实现
                    System.out.println("线程1：执行完毕！");
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();

    }

}

/**
 * 加上volatile后使box的修改可以得到通知
 *
 * @author xzq
 */
class Box_6{

    private volatile List<Object> box=new ArrayList<>();

    public void add(Object element){
        box.add(element);
    }

    public int size(){
        return box.size();
    }

}

在这里插入图片描述

我想砍你
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c语言线程间传递消息,线程间通信
weixin_34547628的博客
05-22 3403
线程间通信前面一章讲了线程间同步，提到了信号量、互斥量、事件集等概念；本章接着上一章的内容，讲解线程间通信。在裸机编程中，经常会使用全局变量进行功能间的通信，如某些功能可能由于一些操作而改变全局变量的值，另一个功能对此全局变量进行读取，根据读取到的全局变量值执行相应的动作，达到通信协作的目的。RT-Thread 中则提供了更多的工具帮助在不同的线程中间传递信息，本章会详细介绍这些工具。学习完本章，...
1.10 第三章进程线程间通信
01-10
1.10 第三章进程线程间通信
【18】java锁之wait,notify(wait会释放锁，notify仅仅只是通知，不释放锁)
azhegps的博客
03-18 2万+
       wait是指在一个已经进入了同步锁的线程内，让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify方法（notify并不释放锁，只是告诉调用过wait方法的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放），调用wait方法的一个或多个线程就会解除wait状态，重新参与竞争对象锁，程序如果可以再次得到锁，就...
Java 线程间通信
WYSCODER的博客
04-17 5586
Java线程间通信
进程间通信&线程间通信
渣渣
07-26 2257
一、多进程： 首先，先来讲一下fork之后，发生了什么事情。 由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是因为它随时可以调用getpid()来获取自己的pid；也可以调用getppid()来获取父进程的id
进程间通信和线程间通信总结
小小默：进无止境
02-16 1万+
写在前面 面试的时候一定不要疲劳战，比如上午面了一个，然后中午不休息直接赶到另外一个相距比较远的公司，影响状态。 面试的时候一定不要紧张，不管对方有几个人，总之面试的时候做好充分准备，休息好，放松心态。 好了，言归正传，开始总结。 【1】进程间通信方式 进程间通信又称IPC(Inter-Process Communication),指多个进程之间相互通信，交换信息的方法。根据进程通信时信息量大小的...
线程间通信
weixin_53812805的博客
05-02 4115
目录 一、线程理论基础 1、什么是线程 2、为什么有了进程，还要引入线程呢？ （使用多线程到底有哪些好处？） 3、线程的缺点 二、多线程间通信 1、多线程通信的注意事项 2、创建线程的步骤 3、终止线程的方式 4、线程 API 使用 （1）pthread_create() 函数 （创建线程） （2）pthread_exit()函数 （结束线程） （3）pthread_join()函数 （等待线程结束） 三、线程同步 1、互斥量 （1）互斥量注意事项 （2）互斥锁创建步..
11_C++多线程及线程间通信
卡木
08-08 6827
参考： https://m.imooc.com/article/289630 C++11 标准库新引入的线程库 https://www.jianshu.com/p/e5a3498ba930 （一）多线程编程 #include <iostream> #include <thread> #include <mutex> #include <condi...
python中的线程间通信
瑞瑞的博客
04-28 2516
前面学习了线程的一些基本知识如与进程的区别，线程的组成，线程如何创建等，接下来继续线程的学习。
进程间通信和线程间通信
feelinghappy的专栏
08-18 4361
进程间通信 转自 https://www.cnblogs.com/LUO77/p/5816326.html 线程间通信 https://www.cnblogs.com/jobs1/p/10784021.html 线程间通信 进程和线程的区别 程序只是一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体。而进程则不同，它是程序在某个数据集上的执行。进程是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映...
c++ 线程间通信方式
热门推荐
天行九歌
07-28 3万+
线程同步和线程互斥 互斥：是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。但互斥无法限制访问者对资源的访问顺序，即访问是无序的，线程间不需要知道彼此的存在。 同步：是指在互斥的基础上（大多数情况），通过其它机制实现访问者对资源的有序访问，线程间知道彼此的存在。在大多数情况下，同步已经实现了互斥，特别是所有写入资源的情况必定是互斥的。少数情况是指可以允许多个访问者同时访问资源 线程...
MFC线程间通信
04-05
然而，当一个应用程序中有多个线程运行时，它们可能需要共享数据或协调工作，这就涉及到线程间通信（Inter-Thread Communication，简称ITC）。MFC（Microsoft Foundation Classes）库，作为Windows平台上C++开发的...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信...总之，Linux下的多线程通信依赖于同步原语如互斥锁和条件变量，以确保线程安全地共享资源和协作执行任务。通过理解这些概念和技术，开发者可以有效地编写出高效且并发安全的多线程程序。
chromedriver-mac-arm64_126.0.6465.0.zip
07-31
chromedriver-mac-arm64_126.0.6465.0.zip
chromedriver-mac-x64_122.0.6235.0.zip
最新发布
07-31
chromedriver-mac-x64_122.0.6235.0.zip
chromedriver-mac-x64_122.0.6188.0.zip
07-31
chromedriver-mac-x64_122.0.6188.0.zip
【JCR2区】基于matlab阿基米德算法优化最小二乘法AOA-LSSVM数据分类【含Matlab源码 6004期】.zip
07-31
CSDN海神之光上传的代码均可运行，亲测可用，换数据就行，适合小白； 1、代码压缩包内容 主函数：main.m； 数据； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，可私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开除main.m的其他m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博主博客文章底部QQ名片； 4.1 CSDN博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 智能优化算法优化最小二乘法支持向量机LSSVM分类预测系列程序定制或科研合作方向： 4.4.1 遗传算法GA/蚁群算法ACO优化LSSVM 4.4.2 粒子群算法PSO/蛙跳算法SFLA优化LSSVM 4.4.3 灰狼算法GWO/狼群算法WPA优化LSSVM 4.4.4 鲸鱼算法WOA/麻雀算法SSA优化LSSVM 4.4.5 萤火虫算法FA/差分算法DE优化LSSVM 4.4.6 其他优化算法优化LSSVM
thread线程间通信
08-22
线程间通信是指不同线程之间进行数据交换和共享信息的过程。线程间通信的目的是协调不同线程的执行顺序，实现数据的传递和共享。 在C语言中，常用的线程间通信方式有以下几种： 1. 共享内存：多个线程共享同一块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值