（6）Java之多线程通信

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方法可以达到线程等待的效果
• 什么是等待通知机制（注意：等待通知机制的应用远远不止本博客中的实例，下一篇博客中将重点介绍等待通知机制的经典实例：生产者/消费者模式）