多线程-生产者和消费者模式

1. 生产者和消费者模式概述

• 概述

  生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

  所谓生产者消费者问题，实际上主要是包含了两类线程：

  • 一类是生产者线程用于生产数据
  • 一类是消费者线程用于消费数据

  为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

  生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

  消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

• Object类的等待和唤醒方法

  方法名	说明
  void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
  void notify()	唤醒正在等待对象监视器的单个线程
  void notifyAll()	唤醒正在等待对象监视器的所有线程

2. 生产者和消费者案例

• 案例需求

  洗衣房工作，一个洗衣工每 2s 洗一件衣服，一个晾衣工每 1s 晾一件衣服，一共有50件衣服，模拟过程

• 案例分析

  • 工具类 --> 盆(Basin)：定义表示脏衣服数量的变量，定义锁对象变量，定义标记盆里有无洗了的衣服的变量（假设盆比较小，只能同时放一件衣服）

  • 生产者类 --> 洗衣工(Washer)：继承 Thread 类，重写run()方法，设置线程任务

    1. 判断盆里是否有衣服，决定当前线程是否执行
    2. 如果有衣服，就进入等待状态；如果没有衣服，继续执行，洗衣服
    3. 洗好一件衣服之后，更新盆里是否有衣服的状态并唤醒晾衣工晾衣服

  • 消费者类 --> 晾衣工(Drying)：继承 Thread 类，重写run()方法，设置线程任务

    1. 判断盆里是否有衣服，决定当前线程是否执行
    2. 如果没有衣服，就进入等待状态；如果有衣服，就晾衣服
    3. 晾完衣服后，更新盆里是否有衣服的状态并唤醒洗衣工洗衣服

  • 测试类 (WashClothes)：里面有main方法，main方法中的代码步骤如下

    • 创建生产者线程和消费者线程对象
    • 分别开启两个线程

• 实现步骤

  1. while(true) 死循环

  2. synchronized 锁，锁对象要唯一

  3. 判断共享数据是否结束

     • 结束
     • 没有结束

• 代码实现

  工具类（盆）：

  public class Basin {
      // 定义一个标记，true表示盆里有衣服，此时允许晾衣工执行；false表示没有，此时允许洗衣工执行
      public static boolean flag = false;
  
      // 衣服的数量
      public static int count = 50;
  
      //锁对象
      public static final Object lock = new Object();
  }
  

  生产者（洗衣工）：

  public class Washer extends Thread {
      @Override
      public void run() {
  
          while(true) {
              synchronized (Basin.lock) {
                  // 判断是否还有未洗的衣服
                  if (Basin.count == 0) {
                      // 如果没有则直接结束
                      break;
                  } else {
                      // 如果有，则判断盆里是否有衣服没晾，没有就洗，有就等
                      int i = Basin.count;
                      if(!Basin.flag){
                          try {
                              // 洗衣服
                              Thread.sleep(2000);
                              System.out.println("洗衣工开始洗第 "+ (i--) + " 件衣服啦~");
                              Basin.flag = true;
                              Basin.lock.notifyAll();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      } else {
                          try {
                              Basin.lock.wait();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      }
                  }
              }
          }
      }
  }
  

  消费者（晾衣工）：

  public class Drying extends Thread {
      @Override
      public void run() {
          while (true) {
              synchronized (Basin.lock) {
                  if (Basin.count == 0) {
                      break;
                  } else {
                      int i = Basin.count;
                      if (Basin.flag) {
                          try {
                              // 晾衣服
                              Thread.sleep(1000);
                              System.out.println("晾衣工开始晾第 " + (i--) + " 件衣服啦~");
                              Basin.flag = false;
                              Basin.lock.notifyAll();
                              Basin.count--;
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      } else {
                          try {
                              Basin.lock.wait();
                          } catch (InterruptedException e) {
                              e.printStackTrace();
                          }
                      }
                  }
              }
          }
      }
  }
  

  测试类：

  public class WashClothes {
      public static void main(String[] args) {
          Washer w = new Washer();
          Drying d = new Drying();
  
          w.start();
          d.start();
      }
  }
  

  
  
  
  

---

以上就是我个人目前对多线程里面的生产者与消费者的理解，如果有不对或者是不全面的地方，欢迎各位大佬来指正补充