- 引言
- 通信一多个线程共享同一个变量
- 1代码实现多个线程共享arr对象
- 通信二B线程等待A线程执行完join
- 1 错误代码
- 2 正确代码使用join方法
- 3 join方法的使用
- 通信三多个线程共享数据通过管道流共享数据
- 1 代码实现
- 2管道流之间的交互过程
- 通信四
- 1不使用等待通知机制的线程交互
- 2 等待通知机制进行线程之间的交互
- 3 等待通知机制的原理
- 总结
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方法可以达到线程等待的效果
- 什么是等待通知机制（注意：等待通知机制的应用远远不止本博客中的实例，下一篇博客中将重点介绍等待通知机制的经典实例：生产者/消费者模式）
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
