软件都是由不同的模块组成一个系统，从而模块与模块间的通信，线程与线程间通信是经常碰到的。下面我们介绍了关于线程间通信的几种技术方案
1.wait/notify
1.1不使用wait/notify的代码演示
public class TpadTask {
private List<Integer> list = new ArrayList<>();
public void doAdd() {
Integer num = new Random().nextInt(100);
list.add(num);
}
public int size() {
return list.size();
}
}
public class ThreadA extends Thread {
private TpadTask task;
public ThreadA(TpadTask task) {
super();
this.task = task;
}
@Override
public void run() {
for(int i=0;i<10;i++){
task.doAdd();
System.out.println(i);
}
}
}
public class ThreadB extends Thread {
private TpadTask task;
public ThreadB(TpadTask task) {
super();
this.task = task;
}
@Override
public void run() {
try {
while (true) {
if (task.size() == 5) {
System.out.println("已达到5，b线程要退出");
throw new InterruptedException();
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
public class Client {
public static void main(String[] args) {
TpadTask task = new TpadTask();
ThreadA a = new ThreadA(task);
ThreadB b = new ThreadB(task);
a.start();
b.start();
}
}
说明：线程A是进行对list进行添加数据，线程B是对list的大小进行监控，如果达到5，则主动退出，抛出异常。
- 结果
0
1
2
3
4
已达到5，b线程要退出
5
6
7
8
9
java.lang.InterruptedException
at communication.ThreadB.run(ThreadB.java:21)
缺点：
- 线程B需要不停的循环来判断定条件，这样会浪费CPU资源。
1.2 wait/notify机制
- 1.wait()
wait()的作用是使当前执行的线程进行等待,wait()方法是Object类的方法。该方法是将当前线程置入预执行队列，并在wait代码处停止执行，直到接收到通知或被中断执行。
在调用wait()之前，线程必须获取该对象的对象级别锁，即只能在同步方法或者同步代码块中调用wait()方法。
在执行wait()方法后，当前线程释放锁。从wait()返回前，线程与其他线程竞争重新获取锁。如果调用wait()没有持有锁，则会抛出异常。
- wait方法的注释
The current thread must own this object's monitor.
- 2.notify()
notify()的作用是使停止的线程继续运行。
在调用notify()之前，线程必须获取该对象的对象级别锁，也只能在同步方法或者同步代码块调用
执行notify()方法后，当前线程不会马上释放该对象锁。呈现wait的线程也不会马上获取到该对象锁。要等到执行notify()方法的线程将程序执行完。也就是退出synchronized代码块后，当前线程才会释放该对象锁。
3.改造上述代码
TpadTask代码不变
ThreadA代码改造
public class ThreadA extends Thread {
private TpadTask task;
private Object lock;
public ThreadA(TpadTask task, Object obj) {
super();
this.task = task;
this.lock = obj;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
try {
synchronized (lock) {
task.doAdd();
System.out.println(i);
if (task.size() == 5) {
lock.wait();
System.out.println("接收到信息！！！");
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
- ThreadB
public class ThreadB extends Thread {
private TpadTask task;
private Object lock;
public ThreadB(TpadTask task, Object obj) {
super();
this.task = task;
this.lock = obj;
}
@Override
public void run() {
try {
synchronized (lock) {
if (task.size() == 5) {
lock.notify();
System.out.println("已发出信号！！！");
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
- 测试
public class Client {
public static void main(String[] args) throws InterruptedException {
TpadTask task = new TpadTask();
Object lock = new Object();
ThreadA a = new ThreadA(task, lock);
a.start();
ThreadB b = new ThreadB(task, lock);
b.start();
}
}
- 结果
0
1
2
3
4
已发出信号！！！
接收到信息！！！
5
6
7
8
9
- 4.线程状态切换
- 5.wait(long timeout)
等待一段时间，看是否有线程对锁进行唤醒。如果超过这个时间，则自动唤醒。
2.通过管道流进行通信(pipeStream)
jdk提供了4个类用于管道流通信。java.io.PipedInputStream、java.io.PipedOutputStream、java.io.PipedReader、java.io.PipedWriter
它们的作用是让多线程可以通过管道进行线程间的通讯。在使用管道通信时，必须将PipedOutputStream和PipedInputStream配套使用。
大致的流程是：我们在线程A中向PipedOutputStream中写入数据，这些数据会自动的发送到与PipedOutputStream对应的PipedInputStream中，进而存储在PipedInputStream的缓冲中；此时，线程B通过读取PipedInputStream中的数据。就可以实现，线程A和线程B的通信。
PipedOutputStream、PipedInputStream代码演示
新建生产消息线程
public class Producer extends Thread {
private PipedOutputStream pos;
public Producer(PipedOutputStream pos) {
this.pos = pos;
}
@Override
public void run() {
super.run();
try {
pos.write("Hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 新建接收消息线程
public class Consumer extends Thread {
private PipedInputStream pis;
public Consumer(PipedInputStream pis) {
this.pis = pis;
}
@Override
public void run() {
super.run();
byte[] b = new byte[100]; // 将数据保存在byte数组中
try {
int len = pis.read(b); // 从数组中得到实际大小。
System.out.println(String.format("接收到信号：%s",new String(b, 0, len)));
pis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 测试
public class Client {
public static void main(String[] args) throws IOException, InterruptedException {
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream();
try {
pos.connect(pis);// 连接管道
new Producer(pos).start();// 启动线程
new Consumer(pis).start();// 启动线程
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 结果
接收到信号：Hello
pos.connect(pis)作用是将“管道输入流”和“管道输出流”关联起来。查看PipedWriter.java和PipedReader.java中connect()的源码；我们知道 out.connect(in); 等价于 in.connect(out)。当然JDK还支持管道通信字符流。
3.Join
主线程创建并启动子线程，如果子线程需要消耗大量的资源，主线程往往早于子线程执行完毕。而主线程需要等待子线程的结果，这时候使用join方法。
- 例子
public class CustomerThread extends Thread {
public CustomerThread(){
super();
}
@Override
public void run() {
System.out.println("我是子线程代码");
}
}
public class Client {
public static void main(String[] args) throws InterruptedException {
CustomerThread a=new CustomerThread();
a.start();
System.out.println("我是主线程代码");
}
}
- 输出
我是主线程代码
我是子线程代码
主线程已经执行完毕了，才执行子线程，如果需要用到子线程的结果。那么只需要加一句join()。
public class Client {
public static void main(String[] args) throws InterruptedException {
CustomerThread a=new CustomerThread();
a.start();
a.join();//join语句
System.out.println("我是主线程代码");
}
}
- 结果
我是子线程代码
我是主线程代码
join的方法注释是:
/**
* Waits at most {@code millis} milliseconds for this thread to
* die. A timeout of {@code 0} means to wait forever.
*/
while (isAlive()) {
wait(0);
}
使得所属的线程对象正常的执行，使得当前的线程进行无线等待，直到所属线程销毁后，再执行当前线程。
在join过程中，如果当前线程对象被中断，则当前线程对象抛出异常。
join(long)中的参数是等待的时间。例如join(2000)，只等等2秒子线程的执行时间。超过2秒自动执行主线程代码。
3.1join(long)与sleep(long)的区别
join内部使用的是wait(long)来实现的。所以join()具有释放锁的特性。当前线程的锁被释放，那么其他线程就可以调用此线程的同步方法了。
Thread.sleep(long)方法却不释放锁。
4.ThreadLocal
ThreadLocal并不是一个Thread，而是Thread的局部变量，也许把它命名为ThreadLocalVariable更容易让人理解一些。
ThreadLocal是解决每个线程绑定属于自己的值。
ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本。解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。
代码演示
新建ThreadLocal公用类
public class ThreadLocalVariable {
public static ThreadLocal threadLocalVariable = new ThreadLocal();
}
- 新建ThreadA
public class ThreadA extends Thread {
@Override
public void run() {
try {
for(int i=0;i<5;i++){
ThreadLocalVariable.threadLocalVariable.set(String.format("ThreadA:%s",i));
System.out.println(ThreadLocalVariable.threadLocalVariable.get());
}
}
catch (Exception ex){
ex.printStackTrace();
}
}
}
- 新建ThreadB
public class ThreadB extends Thread {
@Override
public void run() {
try {
for(int i=0;i<5;i++){
ThreadLocalVariable.threadLocalVariable.set(String.format("ThreadB:%s",i));
System.out.println(ThreadLocalVariable.threadLocalVariable.get());
}
}
catch (Exception ex){
ex.printStackTrace();
}
}
}
- Client
public class Client {
public static void main(String[] args) {
ThreadA a = new ThreadA();
ThreadB b = new ThreadB();
a.start();
b.start();
ThreadLocalVariable.threadLocalVariable.set("a");
System.out.println(ThreadLocalVariable.threadLocalVariable.get());
}
}
- 结果
a
ThreadA:0
ThreadA:1
ThreadA:2
ThreadA:3
ThreadA:4
ThreadB:0
ThreadB:1
ThreadB:2
ThreadB:3
ThreadB:4
每个线程都对threadLocalVariable进行设置值，但是取值的时候，都是取的各自的设置的值。
没赋值前返回的值是null
protected T initialValue() {
return null;
}
4.1InheritableThreadLocal
该类可以让子线程从父线程中取出值。而子线程从父类继承的值可以在子线程进行对值得修改
