Java多线程(3)

七、线程间通信
线程间通信，主要介绍问题的引出和如何解决等内容。

1、问题的引出
实例：
把一个数据存储空间划分为两个部分：一部分用于存储人的姓名，另一部分用于存储人的性别。这里包含两个线程：一个线程向数据存储空间添加数据(producer)，另一个线程从数据存储空间去除数据(consumer)。这个应用会出现两种意外。
第一种意外：假设producer刚向数据存储空间添加了一个人的姓名，还没有加入这个人的性别，cpu就切换到consumer线程，consumer则把这个人的姓名和上一个人的性别联系到了一起。
第二种意外：producer放入了若干次数据，consumer才开始取数据，或者是，consumer 取完一个数据后，还没等到producer放入新的数据，又重复取出已去过的数据。

2、问题如何解决
程序中的生产者线程和消费者线程运行的是不同的程序代码，因此编写包含run方法的两个类来完成这两个线程，一个是生产线程Producer，另一个是消费者线程Consumer。

class Producer implements Runnable {

public void run(){
//数据空间存放数据
}
}

class Consumer implements Runnable{

public void run(){
//从数据空间读取数据
}
}

还需要定义一个数据结构来存储数据

class P{
String name;
String sex;
}

范例1：
class P{
String name = "LiSi";
String sex = "Girl";
}

class Producer implements Runnable {
P q = null;
public Producer(P q){
this.q = q;
}

public void run(){
int i = 0;
while(true){
if(i==0){
q.name = "ZhangSan";
q.sex = "Boy";
}else{
q.name = "Lisi";
q.sex = "Girl";
}
i = (i+1)%2;
}
}
}

class Consumer implements Runnable{
P q = null;
public Consumer (P q){
this.q = q;
}

public void run(){
while(true){
System.out.println(q.name+"----->"+q.sex);
}
}
}

public class Test {
public static void main(String args[]){
P q = new P();
Thread pro = new Thread(new Producer(q));
Thread con = new Thread(new Consumer(q));
pro.start();
con.start();
}
}

运行结果片段：
......
Lisi----->Girl
ZhangSan----->Boy
ZhangSan----->Boy
Lisi----->Girl
Lisi----->Boy
ZhangSan----->Girl
ZhangSan----->Boy
ZhangSan----->Girl
ZhangSan----->Boy
Lisi----->Boy
Lisi----->Boy
ZhangSan----->Boy
ZhangSan----->Girl
......

从运行结果来看，打印出现了混乱的情况，这是什么原因？在程序中，Producer类和Consumer类都操纵了同一个P类，这就是有可能出现Producer类还未操纵玩P类，Consumer类就已经将P类中的内容取走了，这就是资源不同步的原因。为此，可在P类中增加两个同步方法：set()和get()。

范例2：
class P{
String name = "LiSi";
String sex = "Girl";
public synchronized void set(String name,String sex){
this.name = name;
this.sex = sex;
}
public synchronized void get(){
System.out.println(this.name+"----->"+this.sex);
}
}

class Producer implements Runnable {
P q = null;
public Producer(P q){
this.q = q;
}

public void run(){
int i = 0;
while(true){
if(i==0){
q.set("ZhangSan","BOy");
}else{
q.set("LiSi","Girl");
}
i = (i+1)%2;
}
}
}

class Consumer implements Runnable{
P q = null;
public Consumer (P q){
this.q = q;
}

public void run(){
while(true){
q.get();
}
}
}

public class Test {
public static void main(String args[]){
P q = new P();
Thread pro = new Thread(new Producer(q));
Thread con = new Thread(new Consumer(q));
pro.start();
con.start();
}
}
运行结果：
........
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
LiSi----->Girl
.......
这个输出结果顺序上没有任何问题，但又有新的问题产生。Consumer线程对Producer线程放入的一次数据连续的读取了多次，这并不符合实际的要求。实际要求的结果是，Producer方一次数据，Consumer就取一次；反之，Producher也必须等到Consumer取完后才能放入新的数据，而这一问题的解决就需要使用下面讲到的线程间的通信。
Java是通过Object类的wait、notify、notifyAll这几个方法来实现线程间的通信的，又因为所有的类都是从Object继承的，所以任何类都可以直接使用这些方法。
wait：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止；
nofity：唤醒同一对象监视器中调用wait的第一个线程。这类似于排队买票，一个人买完之后，后面的人才可以继续买；
notifyAll：唤醒同一对象监视器中调用wait的所有线程，具有最高优先级的线程首先被唤醒并执行。
我们现在将P类修改如下：
class P{
String name = "LiSi";
String sex = "Girl";
boolean bFull = false;

public synchronized void set(String name,String sex){
if(bFull){
try{
wait();
}catch(InterruptedException e){}
}
this.name = name;
try{
Thread.sleep(10);
}catch(Exception e){}
this.sex = sex;
bFull = true;
notify();
}

public synchronized void get(){
if(!bFull){
try{
wait();
}catch(InterruptedException e){}
}
System.out.println(this.name+"----->"+this.sex);
bFull = false;
notify();
}
}
当Consumer线程取走数据后，bFull值为false，当Producer线程放入数据后，bFull值为true。只有bFull为true时，Consumer线程才能取走数据，否则就必须等待Producer线程放入新的数据后的通知；反之，只有bFull为false，Producer线程才能放入新的数据，否则就必须等待Consumer线程取走数据后的通知。
运行结果如下：
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
ZhangSan----->BOy
LiSi----->Girl
wait、notify、notifyAll这3个方法只能在synchronized方法中调用，即无论线程调用一个对象的wait还是notify方法，该线程必须先得到该对象的锁标记。这样，notify就只能唤醒同一对象监视器中调用wait的线程。而使用多个对象监视器，就可以分别有多个wait、notify的情况，同组里的wait只能被同组的notify唤醒。