wait()+notify实现java生产者-消费者

（一）、问题的引出

有一个数据存储空间,划分为两部分,一部分用于存储人的姓名,另一部分用于存储人的性别;

我们的应用包含两个线程,一个线程不停向数据存储空间添加数据(生产者),另一个线程从数据空间取出数据(消费者);

因为线程的不确定性，存在于以下两种情况：

1.若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；

2.生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

/**
* 模拟数据区域
*
*/
class Person{

private String name;

private String sex;

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}
}
/**
* 生产者
*/
class Producer implements Runnable{

private Person p;

public Producer(Person p){
this.p = p;
}

public void run() {
for (int i = 0; i < 100; i++) {
if(i % 2== 0){
p.setName("大哥");
try {
Thread.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setSex("男");
}else{
p.setName("小姐");
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
p.setSex("女");
}
}
}
}

class Consumer implements  Runnable{
private Person p;

public Consumer(Person p){
this.p = p;
}
public void run() {
for (int i = 0; i < 100; i++) {
String name = p.getName();
String sex = p.getSex();
System.out.println(name+" --> " + sex);
}
}

}
public class Producer_ConsumerDemo {
public static void main(String[] args) {
Person p = new Person();

new Thread(new Producer(p)).start();
new Thread(new Consumer(p)).start();
}
}

上机运行上述程序，可见问题的结果。每次运行的结果都不一样，但是都是有问题的结果。

接下来的代码是对上述程序问题的解决。当然了，就是解决： 1.若生产者线程刚向存储空间添加了人的姓名还没添加人的性别，CPU就切换到了消费者线程，消费者线程把姓名和上一个人的性别联系到一起；2.生产者放了若干数据，消费者才开始取数据，或者是消费者取完一个数据，还没等到生产者放入新的数据，又重复的取出已取过的数据；

只不过，问题1反映在本例的男女性别的混乱。问题2反映在本例的“大哥----男”和“小姐----女”不是按照我们程序设计的交替出现（生产消费）。

看改进代码：

/**
* 模拟数据存储区域
*
*/
/*
*  设置名字和性别同步完成,
*/
class Person {

private String name;

private String sex;

// 表示存储区域是否为空。
//存储区为空，消费者停止消费，生产者工作；存储区不为空，生产者停止生产，消费者开始消费
private Boolean Empty = Boolean.TRUE;

/**
* 生产者生产人（姓名，性别）
*
*/
public void set(String name, String sex) {
synchronized (this) {
// if(Empty)
while (!Empty.equals(Boolean.TRUE)) {
// 区域不为空
// 此时生产者应该停下来,等着消费者“消费”
try {
this.wait();// 等待 消费者消费
} catch (InterruptedException e) {
e.printStackTrace();
}

}
this.name = name;
//
this.sex = sex;
// 生产者生产之后,应该修改存储区域的状态以显示其存储空间有产品可供“消费”
Empty = Boolean.FALSE;// 不为空
this.notify();// 唤醒消费者起来“消费”，可以理解为读存储空间里的数据
}

}

/**
* 消费者消费（姓名，性别）
*/
public void get() {
synchronized (this) {
// 存储区域为空
while (!Empty.equals(Boolean.FALSE)) {
try {
this.wait();// 等着生产者去生产
} catch (InterruptedException e) {
e.printStackTrace();
}

}
String name = getName();
String sex = getSex();
System.out.println(name + " --> " + sex);

// 消费完成,应该修改存储区域的状态

Empty = Boolean.TRUE;// 空了
this.notify();// 唤醒生产者
}

}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}
}

/**
* 生产者
*/
class Producer implements Runnable {

private Person p;

public Producer(Person p) {
this.p = p;
}

public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
p.set("大哥", "男");
} else {
p.set("小姐", "女");
}
}
}
}

class Consumer implements Runnable {
private Person p;

public Consumer(Person p) {
this.p = p;
}

public void run() {
for (int i = 0; i < 100; i++) {
p.get();
}
}

}

public class Producer_ConsumerDemo {
public static void main(String[] args) {
Person p = new Person();
//加下面的话就相当于两个生产者两个消费者
//new Thread(new Producer(p)).start();
//new Thread(new Consumer(p)).start();

new Thread(new Producer(p)).start();
new Thread(new Consumer(p)).start();
}
}

</pre><pre name="code" class="java"><span style="white-space:pre"></span>

程序结果：

大哥 --> 男

小姐 --> 女

大哥 --> 男

小姐 --> 女

..................

注意：

wait():让当前线程放弃监视器进入等待，直到其他线程调用同一个监视器并调用notify()或notifyAll()为止。

notify():唤醒在同一对象监听器中调用wait方法的第一个线程。

notifyAll():唤醒在同一对象监听器中调用wait方法的所有线程。

wait()、notify()、notifyAll()，这三个方法属于Object 不属于 Thread，这三个方法必须由同步监视对象来调用，两种情况：
1.synchronized修饰的方法，因为该类的默认实例(this)就是同步监视器，所以可以在同步方法中调用这三个方法;

2.synchronized修饰的同步代码块，同步监视器是括号里的对象，所以必须使用该对象（同步监视器）调用这三个方法;

但是下面问题又来了：要是我们使用的是Lock对象来保证同步的,系统中不存在隐式的同步监视器对象,那么就不能使用者三个方法了,那该咋办呢?

解决办法：

Lock代替了同步方法或同步代码块,就用Condition来代替同步监视器的功能;

Condition对象通过Lock对象的newCondition()方法创建;

里面方法包括:

await(): 等价于同步监听器的wait()方法;

signal(): 等价于同步监听器的notify()方法;

signalAll(): 等价于同步监听器的notifyAll()方法;

具体实现情况看下面的代码：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
* 模拟数据区域
*
* 可重入锁没有同步监听对象,咋办呢?
*
* Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
*/
class Person {

// 创建可重入锁对象
private final ReentrantLock lock = new ReentrantLock();

private  final  Condition con = lock.newCondition();
private String name;

private String sex;

// 表示存储区域是否为空
private Boolean Empty = Boolean.TRUE;

/**
* 生产
*
*/
public void set(String name, String sex) {
lock.lock();
while(!Empty.equals(Boolean.TRUE)){
//表示不空状态
try {
con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
this.name = name;
Thread.sleep(1);
this.sex = sex;
isEmpty = Boolean.FALSE;
con.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}

}

/**
* 消费
*/
public void get() {
lock.lock();
while(!Empty.equals(Boolean.FALSE)){
//存储区域为空,消费者应该等着
try {
con.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
try {
String name = getName();
String sex = getSex();
System.out.println(name + " --> " + sex);
//
Empty = Boolean.TRUE;
con.signal();
} finally {
lock.unlock();
}

}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getSex() {
return sex;
}

public void setSex(String sex) {
this.sex = sex;
}
}

/**
* 生产者
*/
class Producer implements Runnable {

private Person p;

public Producer(Person p) {
this.p = p;
}

public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
p.set("大哥", "男");
} else {
p.set("小姐", "女");
}
}
}
}

class Consumer implements Runnable {
private Person p;

public Consumer(Person p) {
this.p = p;
}

public void run() {
for (int i = 0; i < 100; i++) {
p.get();
}
}

}

public class Producer_ConsumerDemo {
public static void main(String[] args) {
Person p = new Person();

new Thread(new Producer(p)).start();
new Thread(new Consumer(p)).start();

}
}

程序结果：

大哥 --> 男

小姐 --> 女

大哥 --> 男

小姐 --> 女

........本文参考众多他人资料..........