（6）Java之多线程通信

最新推荐文章于 2024-02-02 17:53:44 发布

GISer.Wang

最新推荐文章于 2024-02-02 17:53:44 发布

阅读量669

点赞数 1

分类专栏： Java基础文章标签：多线程

本文链接：https://blog.csdn.net/LoveCarpenter/article/details/54601938

版权

Java基础专栏收录该内容

15 篇文章 0 订阅

订阅专栏

引言
通信一多个线程共享同一个变量
- 1代码实现多个线程共享arr对象
通信二B线程等待A线程执行完join
通信三多个线程共享数据通过管道流共享数据
- 1 代码实现
- 2管道流之间的交互过程
通信四
总结

1.引言

在多线程编程当中，如果线程和线程之间相互通信，那么系统的交互性便大大的提高，在此篇博客中就主要记录一下在多线程编程当中，如何进行线程之间的通信功能。

在多线程之间的通信大致分为以下几种：

多个线程共享一个数据变量，比如多个线程操作一个arr对象（数据层面）
某一个线程必须要等待一个线程执行完之后才执行
多个线程共享同一份数据（注意：这里或许不存在变量，使用流来实现）
多个线程之间可以相互操作线程状态，比如（A线程让B线程陷入等待状态，或者A线程让B线程执行）

好了接下来我们就来介绍这四种通信的方式。

2.通信一：多个线程共享同一个变量

这个是最简单一种交互方式，前面的线程安全问题都是这种情况产生的。先看一段代码，看看，这种交互方式是如何实现的。

2.1代码实现（多个线程共享arr对象）

创建我们的线程类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

public class MyThread extends Thread {
    private List arr;
    public MyThread(List arr) {
        this.arr=arr;
    }

    @Override
    public void run() {
        arr.add("10")
    }

}

在main函数中这样实现（这里有10个线程，同时操作arr对象）

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


public class app {
    public static void main(String[] args) throws InterruptedException {
        List arr=Collections.synchronizedList(new ArrayList());

        for(int i=0;i<10;i++)
        {
            MyThread td=new MyThread(arr);
            td.start();
        }
    }

}

3.通信二：B线程等待A线程执行完（join）

在进行这个demo之前，我们先假设一个情景，假设我在A线程中给arr存入一个数组，在main线程中取得A线程中存入的数据,首先我们先写一个错误代码

3.1 错误代码

我们的线程

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;

public class MyThread extends Thread {
    private List arr;
    public MyThread(List arr) {
        this.arr=arr;
    }

    @Override
    public void run() {
        arr.add("10");
    }

}

main线程中的代码

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


public class app {
    public static void main(String[] args) throws InterruptedException {
        List arr=Collections.synchronizedList(new ArrayList());
        MyThread td=new MyThread(arr);
        td.start();
        System.out.println(arr.get(0));

    }

}

运行结果

这里写图片描述

代码报错是因为：main线程执行的速度快，当我们从arr数组中取出数据时，td线程还未向数据存储数据。

3.2 正确代码（使用join方法）

修改main方法为：

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


public class app {
    public static void main(String[] args) throws InterruptedException {
        List arr=Collections.synchronizedList(new ArrayList());
        MyThread td=new MyThread(arr);
        td.start();
        //等待td线程执行完，在执行main线程中的代码
        td.join();
        System.out.println(arr.get(0));

    }

}

运行结果

这里写图片描述

3.3 join方法的使用

join方法有几种重载方法：

td.join() 等待td线程执行完
td.join(long millis) 等待td线程几秒，如果td线程未执行完，主线程继续执行
td.join(long millis, int nanos)等待td线程几秒+纳秒，如果td线程未执行完，主线程继续执行

join方法内部使用的wait方法，主要要和sleep()进行区分，join方法具有释放锁的特点，sleep不会释放锁。wait方法的使用将在第四种通信方式中介绍。

4.通信三：多个线程共享数据（通过管道流共享数据）

注意这种方式和第一种通信方式的区别，我们使用管道流进行线程之间的通讯，jdk给我们提供了两对管道流：

PipedInputStream和PipedOutputStream字节流
PipedWriter和PipedReader字符流

在本次实例中使用字节流演示如何进行线程之间的通讯。

4.1 代码实现

我们实现从td线程输入数据，然后从main线程中取得td线程中的数据

定义我们的线程类

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


public class MyThread extends Thread {
    private PipedOutputStream out;
    public MyThread(PipedOutputStream out) {
        this.out=out;
    }

    @Override
    public void run() {
        try {
            out.write("我是在td线程存入的数据".getBytes());
            out.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }       
    }

}

main线程中的代码

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


public class app {
    public static void main(String[] args) throws Exception {
        PipedInputStream in=new PipedInputStream();
        PipedOutputStream out =new PipedOutputStream();
        in.connect(out);
        //创建线程
        MyThread td=new MyThread(out);
        td.start();
        //等待td线程执行完
        td.join();
        byte[] result=new byte[25]; 
        in.read(result);
        in.close();
        String outString =new String(result);
        System.out.println(outString);

    }

}

运行结果

这里写图片描述

这里一定要注意：我们使用管道流进行线程之间的数据交互。（注意这里和第一种通信方式的区别）

4.2管道流之间的交互过程

首先创建一个PipedInputStream管道流和一个PipedOutputStream输入管道流
建立管道流之间的联系，使用connect方法
在一个线程中使用输出流PipedOutputStream,将输入存储在某一个位置
在另外一个线程中使用输入流PipedInputStream，将数据读入内存中。

5.通信四：

第四种线程之间的通信方式有些特殊，我们知道Java中一切皆对象，所有的对象都直接或者间接的继承了Object，而Object中有三类方法和线程相关，分别是：

wait()方法
notify()方法
notifyAll()方法

这三类方法有什么作用呢？wait(),notify()可以叫做线程中的等待通知机制。接下来我们就逐步认识一下这三个方法。

5.1不使用等待通知机制的线程交互

首先我们先写一个demo，此demo如果不使用等待通知机制会怎么样。
我们的需求是这样的：

创建一个数组arr
创建线程A，线程A负责修改arr数组中的个数
创建线程B，线程B负责监测arr数组个数的变化，如果数组个数等于5，那么输入数组的个数，负责输出数组的内容
线程A的代码

import java.util.List;


public class MyThreadA extends Thread{
    private List arr;
    public MyThreadA(List arr) {
        this.arr=arr;
    }
    public void run() {
        while(true)
        {
            System.out.println("arr数组个数为："+arr.size());
            if(arr.size()==5){
                System.out.println("arr数组个数为5个");
                System.out.println(arr.toString());
                break;
            }
        }
    }

}

线程B的代码

import java.util.List;

public class MyThreadB extends Thread {
    private List arr;

    public MyThreadB(List arr) {
        this.arr = arr;
    }

    public void run() {
        int i = 0;
        while (true) {
            try {
                arr.add(i);
                Thread.sleep(1000);
                if(arr.size==5){
                    break;
                }
                i++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }

}

main方法

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



public class app {
    public static void main(String[] args) throws Exception {
        List arr=new ArrayList();
        MyThreadA tdA=new MyThreadA(arr);
        MyThreadB tdB=new MyThreadB(arr);
        tdA.start();
        tdB.start();

    }

}

运行结果

这里写图片描述

通过运行结果我们知道：线程A一直在检查数组的size，哪怕数组的size没有改变，线程A也一直在检查，这就十分的消耗CPU的资源，我们期待，当数组的size为5的时候，由线程B告诉线程A，此时数组的size为5了，然后让线程A，去输入数组的内容

5.2 等待通知机制进行线程之间的交互

为了节约CPU的资源，我们控制：只有当数组的size改变之后，线程A才会去检查数组的size，数组的size是由线程B控制的，也就是说，当线程B修改数组size的同时，去通知线程A，数组的size改变了，然后线程A去检查数组的大小，这样应该如何去实现呢？

此时我们修改代码（线程A中的代码）

import java.util.List;

public class MyThreadA extends Thread {
    private List arr;
    private Object o;

    public MyThreadA(List arr, Object o) {
        this.arr = arr;
        this.o = o;
    }

    public void run() {
        synchronized (o) {
            try {
                if (arr.size() != 5) {
                    // 线程等待，一直等待到被现成B唤醒
                    // 线程A和线程B之间的交互是通过对象o来实现的
                    System.out.println("arr的大小不等于5，我要等待了~");
                    o.wait();
                }
                System.out.println("arr的大小等于5了");
                System.out.println("arr的内容为：" + arr.toString());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

}

线程B的代码

import java.util.List;

public class MyThreadB extends Thread {
    private List arr;
    private Object o;

    public MyThreadB(List arr, Object o) {
        this.arr = arr;
        this.o = o;
    }

    public void run() {
        synchronized (o) {
            int i = 0;
            while (true) {
                try {
                    arr.add(i);
                    i++;
                    if (arr.size() == 5) {
                        // 唤醒线程a
                        o.notify();
                        break;
                    }
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }

    }

}

main函数中的代码

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



public class app {
    public static void main(String[] args) throws Exception {
        List arr=new ArrayList();
        Object o=new Object();
        MyThreadA tdA=new MyThreadA(arr,o);
        MyThreadB tdB=new MyThreadB(arr,o);
        tdA.start();
        tdB.start();

    }

}

运行结果

这里写图片描述

5.3 等待通知机制的原理

等待通知机制一定是存在同步方法中，也就是wait()方法和notify()方法只能在同步线程中使用
方法wait()的作用是让当前线程处于等待状态。
在调用`wait()之前，必须要获得对象锁，上述的代码就是获得对象o的对象锁
当调用wait()方法之后，线程A释放了对象o的对象锁。注意：这里是立即释放对象锁（立即释放），所以线程A就没有了继续执行方法的权利
当线程B调用notify()方法的时候，线程B不会立即释放对象锁（当线程B将run方法执行完毕才会释放线程锁，更加的准确一点是：执行完同步块的时候释放线程锁（synchronized）。）
notify()方法执行完毕后，当线程B释放对象锁之后，线程 A才会去尝试获得对象锁
notifyAll()方法主要用于多个线程当中，一般大于2个线程，比如有10个线程，都需要获得对象o的对象锁，当具有线程锁的线程调用notify()方法之后，多个（线程等待）的线程随机寻找一个线程使其具有争抢锁的能起（也就是说只能唤醒一个线程），如果调用的是notifyAll()方法，那么所有等待线程都会被唤醒，但是哪一个线程可以抢到锁，还要看情况而定（这里的原理和线程的状态有关）将会在以后线程状态中，专门介绍

6 总结

在此篇博客中主要介绍了：

线程中相互通信的四种方式
如果利用管道流进行线程通信（这里比较别扭）
利用join方法可以达到线程等待的效果
什么是等待通知机制（注意：等待通知机制的应用远远不止本博客中的实例，下一篇博客中将重点介绍等待通知机制的经典实例：生产者/消费者模式）

GISer.Wang

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
（6）Java之多线程通信

引言通信一多个线程共享同一个变量1代码实现多个线程共享arr对象通信二B线程等待A线程执行完join1 错误代码2 正确代码使用join方法3 join方法的使用通信三多个线程共享数据通过管道流共享数据1 代码实现2管道流之间的交互过程通信四1不使用等待通知机制的线程交互2 等待通知机制进行线程之间的交互3 等待通知机制的原理总结1.引言在多线程编程当中，如果
复制链接

扫一扫