Java线程间通信方式

最新推荐文章于 2023-02-17 10:06:57 发布
最新推荐文章于 2023-02-17 10:06:57 发布
阅读量158 收藏
点赞数
分类专栏： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kking_edc/article/details/108994744
版权

一、通过synchronized关键字

public class test {

    public static void main(String[] args) {
        MyObject object=new MyObject();
        ThreadA threadA=new ThreadA(object);
        ThreadB threadB=new ThreadB(object);
        threadA.start();
        threadB.start();
    }

}

class MyObject{
    synchronized public void methodA(){
        //do something
    }

    synchronized public void methodB(){
        //do something
    }
}

class ThreadA extends Thread{
    private MyObject object;

    public ThreadA(MyObject object){
        this.object=object;
    }

    @Override
    public void run(){
        super.run();
        object.methodA();
    }
}

class ThreadB extends Thread{
    private MyObject object;

    public ThreadB(MyObject object){
        this.object=object;
    }

    @Override
    public void run(){
        super.run();
        object.methodB();
    }
}

二、wait和notify

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

public class test {

    public static void main(String[] args) {
        try {
            Object lock=new Object();

            ThreadA a=new ThreadA(lock);
            a.start();

            Thread.sleep(1000);

            ThreadB b=new ThreadB(lock);
            b.start();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

}

class MyList{
    private static List<String> list=new ArrayList<>();

    public static void add(){
        list.add("test");
    }

    public static int size(){
        return list.size();
    }
}

class ThreadA extends Thread{
    private Object lock;

    public ThreadA(Object lock){
        super();
        this.lock=lock;
    }

    @Override
    public void run(){
        try{
            synchronized (lock){
                if(MyList.size()!=5){
                    System.out.println("wait begin:"+System.currentTimeMillis());
                    lock.wait();
                    System.out.println("wait end:"+System.currentTimeMillis());
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{
    private Object lock;

    public ThreadB(Object lock){
        super();
        this.lock=lock;
    }

    @Override
    public void run(){
        try{
            synchronized (lock){
                for(int i=0;i<10;i++){
                    MyList.add();
                    if(MyList.size()==5){
                        lock.notifyAll();
                        System.out.println("已经发出了通知");
                    }
                    System.out.println("添加了"+(i+1)+"个元素");
                    Thread.sleep(1000);
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

结果：

wait begin:1602418383158
添加了1个元素
添加了2个元素
添加了3个元素
添加了4个元素
已经发出了通知
添加了5个元素
添加了6个元素
添加了7个元素
添加了8个元素
添加了9个元素
添加了10个元素
wait end:1602418394166

线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list 的size。

A,B之间如何通信的呢？也就是说，线程A如何知道 list.size() 已经为5了呢？

这里用到了Object类的 wait() 和 notify() 方法。

当条件未满足时(list.size() !=5)，线程A调用wait() 放弃CPU，并进入阻塞状态。

当条件满足时，线程B调用 notify()通知 线程A，所谓通知线程A，就是唤醒线程A，并让它进入可运行状态。

这种方式的一个好处就是CPU的利用率提高了。

但是也有一些缺点：比如，线程B先执行，一下子添加了5个元素并调用了notify()发送了通知，而此时线程A还执行；当线程A执行并调用wait()时，那它永远就不可能被唤醒了。因为，线程B已经发了通知了，以后不再发通知了。这说明：通知过早，会打乱程序的执行逻辑。

三、while轮询

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import java.lang.annotation.Native;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

public class test {

    public static void main(String[] args) {
        MyList list=new MyList();

        ThreadA a=new ThreadA(list);
        a.setName("A");
        a.start();

        ThreadB b=new ThreadB(list);
        b.setName("B");
        b.start();
    }

}


class MyList{
    private List<String> list=new ArrayList<>();

    public void add(){
        list.add("elements");
    }

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


class ThreadA extends Thread{
    private MyList list;

    public ThreadA(MyList list){
        super();
        this.list=list;
    }

    @Override
    public void run(){
        try{
            for(int i=0;i<10;i++){
                list.add();
                System.out.println("添加了:"+(i+1)+"个元素");
                Thread.sleep(1000);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread{
    private MyList list;

    public ThreadB(MyList list){
        super();
        this.list=list;
    }

    @Override
    public void run(){
        try{
            while(true){
                if(list.size()==5){
                    System.out.println("线程B准备退出");
                    throw new InterruptedException();
                }
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

在这种方式下，线程A不断改变条件，线程B不断通过while语句检测这个条件(list.size()==5)是否成立，从而实现了线程间的通信。但是这种方式会浪费CPU资源。

同时这种方式还存在另外一个问题，这就是轮询条件的可见性问题：
线程都是先把变量读取到本地线程栈空间，然后再去修改的本地变量。因此，如果线程B每次都在取本地的条件变量，那么尽管另外一个线程已经改变了轮询的条件，它也察觉不到，这样会造成死循环。

25行对list加上volatile限制后，这时程序会正常退出，不会陷入死循环。

private volatile List<String> list=new ArrayList<>();

四、管道通信

利用java.io.PipedInputStream和java.io.PipedOutputStream进行通信。

生产者每5s提供5个产品，放入管道
消费者每0.5s从管道中取一件产品，并打印剩余产品数量，打印产品信息（以数字替代）

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class test{

    public static void main(String[] args) throws InterruptedException {
        PipedOutputStream pos=new PipedOutputStream();
        PipedInputStream pis=new PipedInputStream();
        try {
            pis.connect(pos);
        }catch (IOException e){
            e.printStackTrace();
        }

        new MyProducer(pos).start();
        new MyConsumer(pis).start();
    }

}

class MyProducer extends Thread{
    private PipedOutputStream outputStream;

    private int index=0;

    public MyProducer(PipedOutputStream outputStream){
        this.outputStream=outputStream;
    }

    @Override
    public void run(){
        while(true){
            try{
                for(int i=0;i<5;i++){
                    outputStream.write(index++);
                }
            }catch (IOException e){
                e.printStackTrace();
            }

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

class MyConsumer extends Thread{

    private PipedInputStream inputStream;

    public MyConsumer(PipedInputStream inputStream){
        this.inputStream=inputStream;
    }

    @Override
    public void run(){
        while (true){
            try {
                Thread.sleep(500);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            try {
                int count=inputStream.available();
                if(count>0){
                    System.out.println("rest product cout"+count);
                    System.out.println("get product"+inputStream.read());
                }
            }catch (IOException e1){
                e1.printStackTrace();
            }
        }
    }
}

https://blog.csdn.net/Hadwin1991/article/details/73527835

你回到了你的家
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程是如何通讯的？
javacn_site的博客
05-26 1589
线程通讯指的是多个线程之间通过共享内存或消息传递等方式来协调和同步它们的执行。在多线程编程中，通常会出现多个线程需要共同完成某个任务的情况，这时就需要线程之间进行通讯，以保证任务能够顺利地执行。线程通讯的实现方式主要有以下两种：共享内存：多个线程可以访问同一个共享内存区域，通过读取和写入内存中的数据来进行通讯和同步。消息传递：多个线程之间通过消息队列、管道、信号量等机制来传递信息和同步状态。
Java 如何实现多线程之间的通讯和协作？
javamyfriend的博客
06-06 633
Java 如何实现多线程之间的通讯和协作？
看了这篇文章，就别担心线程间的通信了！
Simon郎的博客
05-07 2980
线程间的通信 1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 ...
线程之间的通信方式
weixin_41979002的博客
08-02 6444
前言 我只是个搬运工，尊重原作者的劳动成果，本文来源下列文章链接： https://zhuanlan.zhihu.com/p/129374075 https://blog.csdn.net/jisuanji12306/article/details/86363390 线程之间为什么要通信？ 通信的目的是为了更好的协作，线程无论是交替式执行，还是接力式执行，都需要进行通信告知。首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
深入理解JAVA多线程之线程间的通信方式
09-02
下面小编就为大家带来一篇深入理解JAVA多线程之线程间的通信方式。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
关于Java线程间通信-回调.docx
09-26
关于Java线程间通信-回调
java线程间通信的通俗解释及代码示例
08-28
主要介绍了java线程间通信的通俗解释，介绍了线程通信中的几个相关概念，然后分享了线程通信的实现方式及代码示例，具有一定参考价值 ，需要的朋友可以了解下。
Java多线程-线程间的通信
02-02
Java多线程--线程间的通信
java多线程通信图解
11-29
一张图方便理解和掌握java 多线程之间通信的实质 java 多线程 其实就是每个线程都拥有自己的内存空间，多线程之间的通信，比例A线程修改了主内存（main方法的线程）变量，需要把A线程修改的结果同步到主线程中，这时B线程再从主线程获取该变量的值，这样就实现了线程之间的通信。在A线程修改的过程中， 通过加锁的方法防止B线程获取该共享变量的值。锁的机制说白了，就是在获取共享变量的时候，增加了字段标识该字段是否已经被其他线程修改中
线程通信的几种方式
热门推荐
ChineseSoftware的博客
07-01 2万+
一、问题 有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。 二、使用 volatile 关键字 基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 public
Java并发学习 7: 线程之间的通信
过道
04-10 2813
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
线程间通信的常用方式
zh123456_789的博客
02-17 1347
线程间通信的常用方式
Java实现线程间的通信的五种方式
Meiko记录
07-06 2965
如何使两个线程按顺序执行？ 假设有两个线程：线程A和线程B。两个线程都可以依次打印三个数字（1-3）。让我们看一下代码： private static void demo1() { Thread A = new Thread(new Runnable() { @Override public void run() { printNumber("A"); } }); Thread B = new Thre..
线程通信方式
keith的博客
11-10 1150
概念、线程间通信的关键字、通信的四种方式【等待-通知，共享内存、管道流、ReentrantLock/Condition消息队列方式】
【Java多线程】你知道实现Java线程间通信有多少种方法吗？
aaa_hao的博客
03-24 4100
文章目录1. 锁与同步2. 等待/通知机制3. 信号量4. 管道5. 其它通信相关5.1 join() 方法5.2 sleep() 方法sleep() 与 wait() 的区别5.3 ThreadLocal 类5.4 InheritableThreadLocal 合理地使用 Java 多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要掌握 Java 线程的通信方式。下文将介绍 Java 线程之间的几种通信机制和原理。 1. 锁
线程之间的几种通信方式
qq_33807380的博客
05-23 3675
1. 什么是线程间的通信 线程间通信其实就是多个线程在操作同一个资源时，多个线程之间不断切换执行时所发出的信号。例如：需要创建两个线程，一条线程只打印1-26的数字，另一条只打印A-Z的字母，最终打印结果为1A2B3C4D…26Z时，这时就需要使用线程之间的通信来交替完成。 2. 不同实现方式的demo 首先创建一个共用的线程池去管理和运行这两个线程： public class ThreadPoolTest { // 创建一个定长的线程池 private static final Executor
java 线程间通信
最新发布
06-16
Java 中的线程间通信（Thread Communication）是为了让多个线程之间能够协作、同步和共享数据。这是实现并发编程的关键，有助于提高程序的效率和响应性。Java 提供了几种机制来支持线程间通信： 1. **wait() 和 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值