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

程序结果：

大哥 --> 男
小姐 --> 女
大哥 --> 男
小姐 --> 女

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