黑马程序员——生产者消费者问题之线程间通信

------- android培训、java培训、期待与您交流！ ----------

本篇博客将通过代码，分析线程通信的原理。线程通信指的是：一个线程存入数据，另一个线程取出数据。当然，实际中可能出现多个线程存入数据，多个线程读取数据。这里只讨论单个线程写入数据，单个线程读取数据。下面以“生产者消费者”问题为例，分析线程间通信的过程。

为了分析线程通信过程中中会遇到的各种问题，这里循序渐进，先分析线程通信、再分析线程同步、最后才分析线程间通信的生产者消费者问题。

1. 线程通信

线程通信指的是：多个线程操作同一个资源，但是操作动作不同。例如一个线程存储入数据，另一个线程去出数据。

1.1线程通信例子——存储与读取不同步问题

下面的例子演示线程通信的过程，有一个类Resource用于产生资源，Input线程用于创建资源，Output出现用于读取Input线程创建的资源。该程序会产生一个问题：我们希望的数据是姓名为"Mike"对应的性别是"man"，姓名为"罗林"对应的性别是"女"，但是控制台中输出的结果有：Mike——女，罗林——man，这是不安全的。原因是输入数据时，还没有完整输入，输出数据就执行了。也就是说，输入线程还没有执行完run方法时，输出线程就执行run方法读取数据了，所以导致数据不一致的问题。下面一节（1.2）将通过线程同步解决该问题。

package com.itheima.entranceExam.blog;

//资源类
class Resource {
String name;
String sex;
}

//输入线程，该线程用于创建Resource对象的数据
class Input implements Runnable{
private Resource r;
public Input(Resource r) {
this.r = r;
}
public void run() {
int x = 0;
//不停的该Resource对象赋值
while(true) {
if(x == 0) {
r.name = "Mike";
r.sex = "man";
}
else {
r.name = "罗琳";
r.sex = "女";
}
x = (x+1)%2;
}
}
}

//输出线程，该线程用于读取Resource对象的数据
class Output implements Runnable{
private Resource r;
public Output(Resource r) {
this.r = r;
}
public void run() {
//不停地读取Resource对象的成员变量值
while(true) {
System.out.println(r.name+"——"+r.sex);
}
}
}

public class ThreadsCommunication {
public static void main(String[] args) {
Resource r = new Resource();
Input in = new Input(r);
Output out = new Output(r);
//创建两个线程
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
//启动两个线程
t1.start();
t2.start();
}
}

1.2 线程同步解决问题

现在我们通过线程同步，解决上面一节（1.1）中出现的问题。我们知道，上面的例子中，当输入线程执行run方法时，正在循环创建数据：Resource.name="Mike"、Resource.sex="man"，Resource.name="罗琳"、Resource.sex="女"，在此期间输出线程有可能读取这些数据。我们希望只有当输入线程执行完毕这几行创建数据的代码后，输出线程才能读取数据，所以，需要将这几行创建数据的代码放到同步代码块中，输出线程中的输出数据的代码也需要使用同步代码块。这样，我们就可以使用同步代码块来实现两个线程的线程同步，代码如下（为了简便，这里只显示修改部分的代码，Resource类代码和主函数不显示）：

//输入线程，该线程用于创建Resource对象的数据
class Input implements Runnable{
private Resource r;
public Input(Resource r) {
this.r = r;
}
public void run() {
int x = 0;
//不停的给Resource对象赋值
while(true) {
//同步代码块
synchronized (r) {
if(x == 0) {
r.name = "Mike";
r.sex = "man";
}
else {
r.name = "罗琳";
r.sex = "女";
}
x = (x+1)%2;
}
}
}
}

//输出线程，该线程用于读取Resource对象的数据
class Output implements Runnable{
private Resource r;
public Output(Resource r) {
this.r = r;
}
public void run() {
//不停地读取Resource对象的成员变量值
while(true) {
//同步代码块
synchronized (r) {
System.out.println(r.name+"——"+r.sex);
}
}
}
}

1.3 线程间通信-等待唤醒机制

1.2节中的例子，还是存在问题：因为当输入线程获得cup执行权后，就不断地输入数据，而输出线程却无法输出这些及时的数据。当输出线程获得cup执行权后，就不断地输出数据，造成输出的数据相同。下面的图片就说明该问题：



为了解决这些问题，本例将通过wait()和notify()方法对线程进行等待和唤醒。当输入线程输入数据后，输入线程等待，并将输出线程唤醒，让输出线程输出数据。当输出线程输出数据后，将输入线程唤醒，让输入线程输入数据。下面的例子通过标记flag来标记输入和输出。当flag=false时，表示执行输入线程，当flag=true时，表示执行输出线程。

代码如下（为了简便，这里不显示主函数，主函数代码请看1.1节中的内容）：

package com.itheima.entranceExam.blog;

//资源类
class Resource {
String name;
String sex;
//标记：当为false时执行输入线程，当为true时执行输出线程
boolean flag = false;
}

//输入线程，该线程用于创建Resource对象的数据
class Input implements Runnable{
private Resource r;
public Input(Resource r) {
this.r = r;
}
public void run() {
int x = 0;
//不停的给Resource对象赋值
while(true) {
//同步代码块
synchronized (r) {
//第一次时，flag为false，所以执行输入线程创建Resource对象的数据
//之后输入线程和输出线程交替执行，输入线程执行完创建数据后，输出线程马上执行输出数据
if(r.flag)
try {
r.wait();//线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
if(x == 0) {
r.name = "Mike";
r.sex = "man";
}
else {
r.name = "罗琳";
r.sex = "女";
}
x = (x+1)%2;
//改变标记，让输出线程执行
r.flag = true;
r.notify();//唤醒线程
}
}
}
}

//输出线程，该线程用于读取Resource对象的数据
class Output implements Runnable{
private Resource r;
public Output(Resource r) {
this.r = r;
}
public void run() {
//不停地读取Resource对象的成员变量值
while(true) {
//同步代码块
synchronized (r) {
if(!r.flag)
try {
r.wait();//线程等待
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(r.name+"——"+r.sex);
//改变标记，让输入线程执行
r.flag = false;
r.notify();//线程唤醒
}
}
}
}

1.4 优化代码

下面我们优化1.3节中的代码，使其更简单。将1.3节中的同步代码块改写为同步函数，我们不能将run方法改写为同步函数，因为run方法是Runnable类的方法，继承该类的线程类只能重载run方法中的内容，而不能重写。所以，我们可以将输入线程中run方法中的，设置Resource类对象成员变量值的代码，抽取出来放到Resource类的set方法中，并将set方法定义为同步函数。同理，将输出线程中的输出数据的代码抽取出来，放到Resource类的out方法中，并将out方法定义为同步函数。这样，我们就将1.3节中的代码优化了，如下：

package com.itheima.entranceExam.blog;

//资源类
class Resource {
private String name;
private String sex;
private boolean flag = false;

//同步函数：设置Resource类成员变量的值
public synchronized void set (String name, String sex) {
if(flag)
try {
this.wait();//线程等待
} catch (Exception e) {}
this.name = name;
this.sex = sex;
flag = true;
this.notify();//唤醒线程
}

//同步函数：输出Resource类成员变量的值
public synchronized void out() {
if(!flag) {
try {
this.wait();//线程等待
} catch (Exception e) {}
}
System.out.println(name+"——"+sex);
flag = false;
this.notify();//唤醒线程
}
}

//输入线程
class Input implements Runnable{
private Resource r;
public Input(Resource r) {
this.r = r;
}
public void run() {
int x = 0;
while(true) {
if(x == 0)
r.set("Mike", "man");
else
r.set("罗琳", "女");
x = (x+1)%2;
}
}
}

//输出线程
class Output implements Runnable{
private Resource r;
public Output(Resource r) {
this.r = r;
}
public void run() {
while(true) {
r.out();
}
}
}

2. 线程通信实现生产者消费者问题

通过上面的第1节的学习，我们初步掌握了线程通信的机制，以及如何实现线程同步。现在我们就应用这些知识点来实现“生产者消费者”的问题。

生产者消费者问题分析：生产者是输入线程，消费者是输出线程。当生产者生产商品时（也就是输入线程创建数据），消费者等待。当生产者生产完毕一件商品后，生产者线程等待，消费者线程执行并消费该商品（输出商品）。就只要，生产者和消费者交替执行，只有生产者生产一件视商品，消费者马上消费该商品。为了便于说明，我们该每个商品都编号，每个商品只对应唯一的一个编号，消费者只能消费一次某一个编号的商品，代码如下：

package com.itheima.entranceExam.blog;

//资源类
class Resource {
private String name;
//计数器，用来给商品编号
private int count = 1;
private boolean flag = false;

//同步函数：设置Resource对象的成员变量数据
public synchronized void set(String name) {
if(flag)
try {
this.wait();//线程等待
} catch (Exception e) {}
this.name = name+":"+count++;
//Thread.currentThread().getName()表示获取当前线程的名称，下同
System.out.println(Thread.currentThread().getName()+"  生产者  "+this.name);
flag = true;
this.notify();//唤醒线程
}

//同步函数：输出Resource类对象的成员变量数据
public synchronized void out() {
if(!flag)
try {
this.wait();//线程等待
} catch (Exception e) {}
System.out.println(Thread.currentThread().getName()+"  消费者  "+this.name);
flag = false;
this.notify();//唤醒线程
}
}

//生产者
class Producer implements Runnable {
private Resource res;

public Producer(Resource res) {
this.res = res;
}

public void run() {
while(true) {
res.set("商品");
}
}
}

//消费者
class Consumer implements Runnable {
private Resource res;

public Consumer(Resource res) {
this.res = res;
}

public void run() {
while(true) {
res.out();
}
}
}

public class ProducerConsumer {
public static void main(String[] args) {
Resource r = new Resource();
Producer pro = new Producer(r);
Consumer con = new Consumer(r);
Thread t1 = new Thread(pro);
Thread t2 = new Thread(con);
t1.start();
t2.start();
}
}