Java多线程：生产者消费者模型

Posted 2022-07-19 流楚丶格念

文章目录

• 1.生产者消费者
• • 1.1 生产者和消费者模式概述
  • 1.2 经典案例：生产者和消费者
  • • 1.2.1 Object类的等待和唤醒方法
    • 1.2.2 代码实现
  • 1.3 生产者和消费者案例优化
  • • 1.3.1 代码实现

1.生产者消费者

生产者消费者模式是一个十分经典的多线程协作的模式

1.1 生产者和消费者模式概述

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

1. 一类是生产者线程用于生产数据
2. 一类是消费者线程用于消费数据

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

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

我们来看一个经典案例，可经典了，上课学，代码学，很多地方都会学到

1.2 经典案例：生产者和消费者

案例需求，有两个实体类，分别进行如下行为：

• 桌子类(Desk)：定义表示糖果数量的变量,定义锁对象变量,定义标记桌子上有无糖果的变量
• 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

小A又来了，刚学完线程同步，他觉得自己又行了

他设计了如下的步骤：

生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

1. 判断是否有糖果,决定当前线程是否执行

2. 如果有糖果,就进入等待状态,如果没有糖果,继续执行,生产糖果

3. 生产糖果之后,更新桌子上糖果状态,唤醒消费者消费糖果

消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

1. 判断是否有糖果,决定当前线程是否执行

2. 如果没有糖果,就进入等待状态,如果有糖果,就消费糖果

3. 消费糖果后,更新桌子上糖果状态,唤醒生产者生产糖果

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

1. 创建生产者线程和消费者线程对象

2. 分别开启两个线程

1.2.1 Object类的等待和唤醒方法

Java给我们提供了线程等待与唤醒的方法，他是Object的方法，不是Thread独有的：

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

1.2.2 代码实现

注意：使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法

package com.test;

class Desk 
    /*
      定义一个标记:
        true 就表示桌子上有糖果的,此时允许吃货执行
        false 就表示桌子上没有糖果的,此时允许厨师执行
     */
    public static boolean flag = false;

    // 糖果的总数量
    public static int count = 10;
    public static final int total = 10;

    // 锁对象
    public static final Object lock = new Object();


class Cooker extends Thread 
    @Override
    public void run() 
        while(true)
            synchronized (Desk.lock)
                if(Desk.count == 0)
                    break;
                else
                    if(!Desk.flag)
                        //生产
                        System.out.println("厨师正在生产第"+ (Desk.total - Desk.count+1) +"糖果");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    else
                        try 
                            Desk.lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                
            
        
    


class Foodie extends Thread 
    @Override
    public void run() 
        while(true)
            synchronized (Desk.lock)
                if(Desk.count == 0)
                    break;
                else
                    if(Desk.flag)
                        //有
                        System.out.println("吃货在吃第"+ (Desk.total - Desk.count+1) +"糖果");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    else
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try 
                            Desk.lock.wait();
                         catch (InterruptedException e) 
                            e.printStackTrace();
                        
                    
                
            


            synchronized (Desk.lock)
                if (Desk.count==0)
                    break;
                else
                    if (Desk.flag)

                    
                
            
        

    


class Demo 
    public static void main(String[] args) 
          /*消费者步骤：
          1，判断桌子上是否有糖果。
          2，如果没有就等待。
          3，如果有就开吃
          4，吃完之后，桌子上的糖果就没有了
                  叫醒等待的生产者继续生产
          糖果的总数量减一*/

          /*生产者步骤：
          1，判断桌子上是否有糖果
          如果有就等待，如果没有才生产。
          2，把糖果放在桌子上。
          3，叫醒等待的消费者开吃。*/

        Foodie f = new Foodie();
        Cooker c = new Cooker();

        f.start();
        c.start();

    

运行结果如下：

1.3 生产者和消费者案例优化

代码需求：

• 将Desk类中的变量,采用面向对象的方式封装起来
• 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用
• 创建生产者和消费者线程对象,构造方法中传入Desk类对象
• 开启两个线程

1.3.1 代码实现

  public class Desk 
  
      //定义一个标记
      //true 就表示桌子上有糖果的,此时允许吃货执行
      //false 就表示桌子上没有糖果的,此时允许厨师执行
      //public static boolean flag = false;
      private boolean flag;
  
      //糖果的总数量
      //public static int count = 10;
      //以后我们在使用这种必须有默认值的变量
     // private int count = 10;
      private int count;
  
      //锁对象
      //public static final Object lock = new Object();
      private final Object lock = new Object();
  
      public Desk() 
          this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
      
  
      public Desk(boolean flag, int count) 
          this.flag = flag;
          this.count = count;
      
  
      public boolean isFlag() 
          return flag;
      
  
      public void setFlag(boolean flag) 
          this.flag = flag;
      
  
      public int getCount() 
          return count;
      
  
      public void setCount(int count) 
          this.count = count;
      
  
      public Object getLock() 
          return lock;
      
  
      @Override
      public String toString() 
          return "Desk" +
                  "flag=" + flag +
                  ", count=" + count +
                  ", lock=" + lock +
                  '';
      
  
  
  public class Cooker extends Thread 
  
      private Desk desk;
  
      public Cooker(Desk desk) 
          this.desk = desk;
      
  //    生产者步骤：
  //            1，判断桌子上是否有糖果
  //    如果有就等待，如果没有才生产。
  //            2，把糖果放在桌子上。
  //            3，叫醒等待的消费者开吃。
  
      @Override
      public void run() 
          while(true)
              synchronized (desk.getLock())
                  if(desk.getCount() == 0)
                      break;
                  else
                      //System.out.println("验证一下是否执行了");
                      if(!desk.isFlag())
                          //生产
                          System.out.println("厨师正在生产糖果");
                          desk.setFlag(true);
                          desk.getLock().notifyAll();
                      else
                          try 
                              desk.getLock().wait();
                           catch (InterruptedException e) 
                              e.printStackTrace();
                          
                      
                  
              
          
      
  
  
  public class Foodie extends Thread 
      private Desk desk;
  
      public Foodie(Desk desk) 
          this.desk = desk;
      
  
      @Override
      public void run() 
  //        1，判断桌子上是否有糖果。
  //        2，如果没有就等待。
  //        3，如果有就开吃
  //        4，吃完之后，桌子上的糖果就没有了
  //                叫醒等待的生产者继续生产
  //        糖果的总数量减一
  
          //套路:
              //1. while(true)死循环
              //2. synchronized 锁,锁对象要唯一
              //3. 判断,共享数据是否结束. 结束
              //4. 判断,共享数据是否结束. 没有结束
          while(true)
              synchronized (desk.getLock())
                  if(desk.getCount() == 0)
                      break;
                  else
                      //System.out.println("验证一下是否执行了");
                      if(desk.isFlag())
                          //有
                          System.out.println("吃货在吃糖果");
                          desk.setFlag(false);
                          desk.getLock().notifyAll();
                          desk.setCount(desk.getCount() - 1);
                      else
                          //没有就等待
                          //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                          try 
                              desk.getLock().wait();
                           catch (InterruptedException e) 
                              e.printStackTrace();
                          
                      
                  
              
          
  
      
  
  
  public class Demo 
      public static void main(String[] args) 
          /*消费者步骤：
          1，判断桌子上是否有糖果。
          2，如果没有就等待。
          3，如果有就开吃
          4，吃完之后，桌子上的糖果就没有了
                  叫醒等待的生产者继续生产
          糖果的总数量减一*/
  
          /*生产者步骤：
          1，判断桌子上是否有糖果
          如果有就等待，如果没有才生产。
          2，把糖果放在桌子上。
          3，叫醒等待的消费者开吃。*/
  
          Desk desk = new Desk();
  
          Foodie f = new Foodie(desk);
          Cooker c = new Cooker(desk);
  
          f.start();
          c.start();