基于 wait/notify 实现“生产者/消费者”模式

avatar 2018年03月14日10:08:28 6 2259 views
博主分享免费Java教学视频，B站账号：Java刘哥
生产消费互相竞争，最多生产20个
  1. package thread.test;
  3. /**
  4.  * @author 言曌
  5.  * @date 2018/3/14 上午9:19
  6.  */
  8. public class ProductTest {
  11.     public static void main(String args[]) {
  12.         Product product = new Product();
  13.         new Thread(new Producer(product)).start();
  14.         new Thread(new Consumer(product)).start();
  16.     }
  18.     static class Product {
  20.         private static final int MAX_PRODUCT = 20;
  21.         private static final int MIN_PRODUCT = 0;
  23.         private int PRODUCT = 0;
  25.         synchronized public void add() {
  26.             if (this.PRODUCT >= MAX_PRODUCT) {
  27.                 try {
  28.                     System.out.println("产品已满，请稍后生产");
  29.                     wait();
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.                 return;
  34.             }
  35.             this.PRODUCT++;
  36.             System.out.println("生产者生产了第" + this.PRODUCT + "个产品" + ",时间：" + System.currentTimeMillis());
  37.             notifyAll();
  38.         }
  40.         synchronized public void sub() {
  41.             if (this.PRODUCT <= MIN_PRODUCT) {
  42.                 try {
  43.                     System.out.println("产品处于缺货状态");
  44.                     wait();
  45.                 } catch (InterruptedException e) {
  46.                     e.printStackTrace();
  47.                 }
  48.                 return;
  49.             }
  50.             System.out.println("消费者消费了第" + this.PRODUCT + "个产品" + ",时间：" + System.currentTimeMillis());
  51.             this.PRODUCT--;
  52.             notifyAll();
  53.         }
  54.     }
  56.     static class Producer implements Runnable {
  58.         private Product product;
  60.         public Producer(Product product) {
  61.             this.product = product;
  62.         }
  64.         @Override
  65.         public void run() {
  66.             System.out.println("生产者开始生产产品");
  67.             while (true) {
  68.                 try {
  69.                     Thread.sleep(1000);
  70.                 } catch (InterruptedException e) {
  71.                     e.printStackTrace();
  72.                 }
  73.                 product.add();
  74.             }
  75.         }
  76.     }
  78.     static class Consumer implements Runnable {
  80.         private Product product;
  82.         public Consumer(Product product) {
  83.             this.product = product;
  84.         }
  86.         @Override
  87.         public void run() {
  88.             System.out.println("消费者开始消费产品");
  89.             while (true) {
  90.                 try {
  91.                     Thread.sleep(1000);
  92.                 } catch (InterruptedException e) {
  93.                     e.printStackTrace();
  94.                 }
  95.                 product.sub();
  96.             }
  97.         }
  98.     }
  99. }
  生产一个消费一个
  1. package thread.test;
  3. /**
  4.  * @author 言曌
  5.  * @date 2018/3/14 上午9:19
  6.  */
  8. public class ProductTest2 {
  11.     public static void main(String args[]) {
  12.         Product product = new Product();
  13.         new Thread(new Producer(product)).start();
  14.         new Thread(new Consumer(product)).start();
  16.     }
  18.     static class Product {
  20.         volatile private boolean isEmpty = true;
  22.         synchronized public void add() {
  23.             while (!isEmpty) {
  24.                 try {
  25.                     System.out.println("已经有了产品，等待消费");
  26.                     wait();
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  29.                 }
  30.             }
  31.             System.out.println("生产者生产了一个产品，时间" + System.currentTimeMillis());
  32.             isEmpty = false;
  33.             notify();
  34.         }
  36.         synchronized public void sub() {
  37.             while (isEmpty) {
  38.                 try {
  39.                     System.out.println("没有了产品，等待生产");
  40.                     wait();
  41.                 } catch (InterruptedException e) {
  42.                     e.printStackTrace();
  43.                 }
  44.             }
  45.             System.out.println("消费者消费了一个产品，时间" + System.currentTimeMillis());
  46.             isEmpty = true;
  47.             notify();
  48.         }
  49.     }
  51.     static class Producer implements Runnable {
  53.         private Product product;
  55.         public Producer(Product product) {
  56.             this.product = product;
  57.         }
  59.         @Override
  60.         synchronized public void run() {
  61.             while (true) {
  62.                 try {
  63.                     Thread.sleep(1);//强制切换线程
  64.                 } catch (InterruptedException e) {
  65.                     e.printStackTrace();
  66.                 }
  67.                 product.add();//添加一个商品
  68.             }
  69.         }
  70.     }
  72.     static class Consumer implements Runnable {
  74.         private Product product;
  76.         public Consumer(Product product) {
  77.             this.product = product;
  78.         }
  80.         @Override
  81.         synchronized public void run() {
  82.             while (true) {
  83.                 try {
  84.                     Thread.sleep(1);//强制切换线程
  85.                 } catch (InterruptedException e) {
  86.                     e.printStackTrace();
  87.                 }
  88.                 product.sub();//减少一个商品
  89.             }
  90.         }
  91.     }
  92. }
  本文地址：https://liuyanzhao.com/7757.html  
历史上的今天
三月
14日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0