Java 实践：生产者与消费者

实践项目：生产者与消费者【经典多线程问题】

问题引出：

　　生产者和消费者指的是两个不同的线程类对象，操作同一个空间资源的情况。

需求引出：

　　—— 生产者负责生产数据，消费者负责取走数据

　　—— 生产者生产完一组数据之后，消费者就要取走一组数据

设置三个类：数据类、生产类、消费类；生产和消费类是线程类，同时操作同一个数据类；生产类负责每次向数据类中写入一组数据；消费类负责每次从数据类中取出一组数据。

 package hello;

 class Info {  // 数据类
     private String title ;
     private String content;
     public void setTitle(String title) {
         this.title = title ;
     }
     public String getTitle() {
         return title ;
     }
     public String getContent() {
         return content ;
     }
     public void setContent(String content) {
         this.content = content ;
     }

 }

 class Producer implements Runnable { // 生成者类（线程）
     private Info info ;
     public Producer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++ ) {
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             if ( x % 2 == 0 ) {
                 this.info.setTitle("张三");
                 this.info.setContent("男");
             } else {
                 this.info.setTitle("王五");
                 this.info.setContent("男");
             }
         }
     }
 }

 class Consumer implements Runnable {
     private Info info ;
     public Consumer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++) {
             try {
                 Thread.sleep(100);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(this.info.getTitle() + "——" + this.info.getContent());
         }
     }
 }

 public class TestDemo {
     public static void main(String[] args) throws Exception {
         Info info = new Info() ;
         new Thread(new Producer(info)).start();
         new Thread(new Consumer(info)).start();
     }
 }

上例程序执行后，会发现“错位的现象”；出现类似数据为取走，就存入新的数据的错误。【不同步且异步现象导致】

 package hello;

 class Info {  // 数据类
     private String title ;
     private String content;
     public synchronized void set(String title , String content) {
         this.title = title ;
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }

         this.content = content ;
     }
     public synchronized void get() {
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(this.title + "——" + this.content);
     }

 }

 class Producer implements Runnable { // 生成者类（线程）
     private Info info ;
     public Producer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++ ) {
             if ( x % 2 == 0 ) {
                 this.info.set("张三", "男");
             } else {
                 this.info.set("李悦", "女");
             }
         }
     }
 }

 class Consumer implements Runnable {
     private Info info ;
     public Consumer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++) {
             this.info.get();
         }
     }
 }

 public class TestDemo {
     public static void main(String[] args) throws Exception {
         Info info = new Info() ;
         new Thread(new Producer(info)).start();
         new Thread(new Consumer(info)).start();
     }
 }

通过“同步方法”，解决了数据不同步的问题，但是于此而来的问题就是：数据的重复操作。

针对上两例程序，我们通过Object类的支持，来解决数据重复操作的问题：
　　如果像上例的设计，需要在程序中加入一个等待机制；当数据未取则等待数据取出后在存入，当数据未存等待数据存入后取出。而Object类中提供有专门的“等待”。

等待：    public final void wait() throws InterruptedException

唤醒第一个等待线程：    public final void notify() ;

唤醒全部的等待进入：    public final void notifyAll();  //优先级高越有可能先唤醒

通过Object的线程等待和唤醒功能完善程序：

 package hello;

 class Info {  // 数据类
     private String title ;
     private String content;
     private boolean flag = true ;
     // true:表示可以生产，不可以取走
     // false：表示不可以生产，可以取走
     public synchronized void set(String title , String content) {
         if (this.flag == false) { // 发现不可以生产，则等待线程
             try {
                 super.wait();  // 通过super调用自己的超类（父类）Object类中的wait()方法等待线程
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         this.title = title ;
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         this.content = content ;
         this.flag = false ;// 修改标记
         super.notify(); //唤醒其他等待线程
     }
     public synchronized void get() {
         if (this.flag == true) {
             try {
                 super.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         try {
             Thread.sleep(100);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(this.title + "——" + this.content);
         this.flag = true ; //修改标记
         super.notify(); // 唤醒其他线程
     }

 }

 class Producer implements Runnable { // 生成者类（线程）
     private Info info ;
     public Producer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++ ) {
             if ( x % 2 == 0 ) {
                 this.info.set("张三", "男");
             } else {
                 this.info.set("李悦", "女");
             }
         }
     }
 }

 class Consumer implements Runnable {
     private Info info ;
     public Consumer(Info info) {
         this.info = info ;
     }
     @Override
     public void run() {
         for (int x = 0 ; x < 100 ; x ++) {
             this.info.get();
         }
     }
 }

 public class TestDemo {
     public static void main(String[] args) throws Exception {
         Info info = new Info() ;
         new Thread(new Producer(info)).start();
         new Thread(new Consumer(info)).start();
     }
 }

我们依靠Object类中的等待唤醒机制完成了代码的要求。

------------------------