Java——多线程之线程间通信

Java多线系列文章是Java多线程的详解介绍，对多线程还不熟悉的同学可以先去看一下我的这篇博客Java基础系列3：多线程超详细总结，这篇博客从宏观层面介绍了多线程的整体概况，接下来的几篇文章是对多线程的深入剖析。

线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能成为一个整体。线程间的通信就是成为整体的必用方案之一，可以说，使线程间进行通信后，系统之间的交互性会更强大，在大大提高CPU利用率的同时还会使程序员对各线程任务在处理的过程中进行有效的把控与监督。

线程运行状态

1)新创建一个新的线程对象后，再调用它的start()方法，系统会为此线程分配CPU资源，使其处于Runnable(可运行)状态，这是一个准备运行的阶段。如果线程抢占到CPU资源，此线程就处于Running(运行)状态。　　

2)Runnable状态和Running状态可相互切换，因为有可能线程运行一段时间后，有其他高优先级的线程抢占了CPU资源，这时此线程就从Running状态变成Runnable状态。线程进入Runnable状态大体分为如下5种情况：

1. 调用sleep()方法后经过的时间超过了指定的休眠时间。
2. 线程调用的阻塞I0已经返回，阻塞方法执行完毕。
3. 线程成功地获得了试图同步的监视器。
4. 线程正在等待某个通知，其他线程发出了通知。
5. 处于挂起状态的线程调用了resume恢复方法。

3)Blocked是阻塞的意思，例如遇到了一个IO操作，此时CPU处于空闲状态，可能会转而把CPU时间片分配给其他线程，这时也可以称为“暂停”状态。Blocked状态结束后，进入Runnable状态，等待系统重新分配资源。出现阻塞的情况有以下几种：

1. 线程调用sleep()方法，主动放弃占用的处理器资源。
2. 线程调用了阻塞式IO方法，在该方法返回前，该线程被阻塞。
3. 线程试图获得一个同步监视器，但该同步监视器正被其他线程所持有。
4. 线程等待某个通知。
5. 程序调用了suspend方法将该线程挂起。此方法容易导致死锁，尽量避免使用该方法。

4)run()方法运行结束后进入销毁阶段，整个线程执行完毕。

每个锁对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，阻塞队列存储了被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度；反之，一个线程被wait后，就会进入阻塞队列，等待下一次被唤醒。

等待与通知机制

一、不使用等待通知机制实现线程间通信：

我们先不使用等待通知机制来看下如何实现线程间的通信：

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

class MyList{
	private List list=new ArrayList();
	public void add() {
		list.add("小马");
	}
	
	public int size() {
		return list.size();
	}
}

class ThreadA extends Thread{
	private MyList list;
	
	public ThreadA(MyList list) {
		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(Exception e) {
			e.printStackTrace();
		}
	}
}

class ThreadB extends Thread{
	private MyList list;
	
	public ThreadB(MyList list) {
		this.list=list;
	}
	
	@Override
	public void run() {
		while(true) {
			if(list.size()==5) {
				System.out.println("==5了，线程b要退出了");
			}
		}
			
	}
}



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();
		
	}
	
}

运行结果：

添加了1个元素
添加了2个元素
添加了3个元素
添加了4个元素
添加了5个元素
==5了，线程b要退出了
添加了6个元素
添加了7个元素
添加了8个元素
添加了9个元素
添加了10个元素

上述代码要实现的是当list的size为5时，B线程进行操作，实现了AB两个线程之间的通信，但是有一个弊端，就是线程B不停的通过while语句轮询机制来检测某一个条件，造成了CPU资源的浪费。

如果轮询的时间间隔很小，更浪费CPU资源；如果轮询的时间间隔很大，有可能会取不到想要得到的数据。所以就需要有一种机制来实现减少CPU的资源浪费，而且还可以实现在多个线程间通信，它就是“wait/notify”机制。

二、wait/notify机制：

1、什么是等待通知机制：

等待/通知机制在生活中比比皆是，比如在就餐时就会实现

1)厨师做完一道菜的时间不确定，所以厨师将菜品放到“菜品传递台”上的时间也不确定。

2)服务员取到菜的时间取决于厨师，所以服务员就有“等待”(wait)的状态。

3)服务员如何能取到菜呢？这又得取决于厨师，厨师将菜放在“菜品传递台”上，其实就相当于一种通知(notify)，这时服务员才可以拿到菜并交给就餐者。

4)在这个过程中出现了“等待/通知”机制。

需要说明的是，前面示例中多个线程之间也可以实现通信，原因就是多个线程共同访问同一个变量，但那种通信机制不是“等待/通知”，两个线程完全是主动式地读取一个共享变量，在花费读取时间的基础上，读到的值是不是想要的，并不能完全确定。所以现在迫切需要一种“等待/通知”机制来满足上面的需求。

2、等待通知机制的实现：

wait()方法：

方法wait()的作用是使当前执行代码的线程进行等待，wait()方法是Object类的方法，该方法用来将当前线程置入“预执行队列”中，并且在wait所在的代码行处停止执行，直到接到通知或被中断为止。在调用wait()之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait()方法。在执行wait()方法后，当前线程释放锁。在从wait()返回前，线程与其他线程竞争重新获得锁。如果调用wait()时没有持有适当的锁，则抛出IlegalMonitorStateException，它是RuntimeException的一个子类，因此，不需要try-catch 语句进行捕捉异常。

notify()方法：

方法notify()也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁。如果调用notify()时没有持有适当的锁，也会抛出llegalMonitorStateException。该方法用来通知那些可能等待该对象的对象锁的其他线程，如果有多个线程等待，则由线程规划器随机挑选出其中一个呈wait状态的线程，对其发出通知notify，并使它等待获取该对象的对象锁。需要说明的是，在执行notify()方法后，当前线程不会马上释放该对象锁，呈wait状态的线程也并不能马上获取该