• Java之多线程的生产者消费者问题的详细解析

    3.生产者消费者

    3.1生产者和消费者模式概述【应用】

    • 概述

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

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

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

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

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

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

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

    • Object类的等待和唤醒方法

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

    3.2生产者和消费者案例【应用】

    • 案例需求

      • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量

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

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

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

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

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

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

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

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

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

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

        分别开启两个线程

    • 代码实现

      1. public class Desk {
      2. ​
      3.     //定义一个标记
      4.     //true 就表示桌子上有汉堡包的,此时允许吃货执行
      5.     //false 就表示桌子上没有汉堡包的,此时允许厨师执行
      6.     public static boolean flag = false;
      7. ​
      8.     //汉堡包的总数量
      9.     public static int count = 10;
      10. ​
      11.     //锁对象
      12.     public static final Object lock = new Object();
      13. }
      14. ​
      15. public class Cooker extends Thread {
      16. //    生产者步骤：
      17. //            1，判断桌子上是否有汉堡包
      18. //    如果有就等待，如果没有才生产。
      19. //            2，把汉堡包放在桌子上。
      20. //            3，叫醒等待的消费者开吃。
      21.     @Override
      22.     public void run() {
      23.         while(true){
      24.             synchronized (Desk.lock){
      25.                 if(Desk.count == 0){
      26.                     break;
      27.                 }else{
      28.                     if(!Desk.flag){
      29.                         //生产
      30.                         System.out.println("厨师正在生产汉堡包");
      31.                         Desk.flag = true;
      32.                         Desk.lock.notifyAll();
      33.                     }else{
      34.                         try {
      35.                             Desk.lock.wait();
      36.                         } catch (InterruptedException e) {
      37.                             e.printStackTrace();
      38.                         }
      39.                     }
      40.                 }
      41.             }
      42.         }
      43.     }
      44. }
      45. ​
      46. public class Foodie extends Thread {
      47.     @Override
      48.     public void run() {
      49. //        1，判断桌子上是否有汉堡包。
      50. //        2，如果没有就等待。
      51. //        3，如果有就开吃
      52. //        4，吃完之后，桌子上的汉堡包就没有了
      53. //                叫醒等待的生产者继续生产
      54. //        汉堡包的总数量减一
      55. ​
      56.         //套路:
      57.             //1. while(true)死循环
      58.             //2. synchronized 锁,锁对象要唯一
      59.             //3. 判断,共享数据是否结束. 结束
      60.             //4. 判断,共享数据是否结束. 没有结束
      61.         while(true){
      62.             synchronized (Desk.lock){
      63.                 if(Desk.count == 0){
      64.                     break;
      65.                 }else{
      66.                     if(Desk.flag){
      67.                         //有
      68.                         System.out.println("吃货在吃汉堡包");
      69.                         Desk.flag = false;
      70.                         Desk.lock.notifyAll();
      71.                         Desk.count--;
      72.                     }else{
      73.                         //没有就等待
      74.                         //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
      75.                         try {
      76.                             Desk.lock.wait();
      77.                         } catch (InterruptedException e) {
      78.                             e.printStackTrace();
      79.                         }
      80.                     }
      81.                 }
      82.             }
      83.         }
      84. ​
      85.     }
      86. }
      87. ​
      88. public class Demo {
      89.     public static void main(String[] args) {
      90.         /*消费者步骤：
      91.         1，判断桌子上是否有汉堡包。
      92.         2，如果没有就等待。
      93.         3，如果有就开吃
      94.         4，吃完之后，桌子上的汉堡包就没有了
      95.                 叫醒等待的生产者继续生产
      96.         汉堡包的总数量减一*/
      97. ​
      98.         /*生产者步骤：
      99.         1，判断桌子上是否有汉堡包
      100.         如果有就等待，如果没有才生产。
      101.         2，把汉堡包放在桌子上。
      102.         3，叫醒等待的消费者开吃。*/
      103. ​
      104.         Foodie f = new Foodie();
      105.         Cooker c = new Cooker();
      106. ​
      107.         f.start();
      108.         c.start();
      109. ​
      110.     }
      111. }

    3.3生产者和消费者案例优化【应用】

    • 需求

      • 将Desk类中的变量,采用面向对象的方式封装起来

      • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用

      • 创建生产者和消费者线程对象,构造方法中传入Desk类对象

      • 开启两个线程

    • 代码实现

      1. public class Desk {
      2. ​
      3.     //定义一个标记
      4.     //true 就表示桌子上有汉堡包的,此时允许吃货执行
      5.     //false 就表示桌子上没有汉堡包的,此时允许厨师执行
      6.     //public static boolean flag = false;
      7.     private boolean flag;
      8. ​
      9.     //汉堡包的总数量
      10.     //public static int count = 10;
      11.     //以后我们在使用这种必须有默认值的变量
      12.    // private int count = 10;
      13.     private int count;
      14. ​
      15.     //锁对象
      16.     //public static final Object lock = new Object();
      17.     private final Object lock = new Object();
      18. ​
      19.     public Desk() {
      20.         this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
      21.     }
      22. ​
      23.     public Desk(boolean flag, int count) {
      24.         this.flag = flag;
      25.         this.count = count;
      26.     }
      27. ​
      28.     public boolean isFlag() {
      29.         return flag;
      30.     }
      31. ​
      32.     public void setFlag(boolean flag) {
      33.         this.flag = flag;
      34.     }
      35. ​
      36.     public int getCount() {
      37.         return count;
      38.     }
      39. ​
      40.     public void setCount(int count) {
      41.         this.count = count;
      42.     }
      43. ​
      44.     public Object getLock() {
      45.         return lock;
      46.     }
      47. ​
      48.     @Override
      49.     public String toString() {
      50.         return "Desk{" +
      51.                 "flag=" + flag +
      52.                 ", count=" + count +
      53.                 ", lock=" + lock +
      54.                 '}';
      55.     }
      56. }
      57. ​
      58. public class Cooker extends Thread {
      59. ​
      60.     private Desk desk;
      61. ​
      62.     public Cooker(Desk desk) {
      63.         this.desk = desk;
      64.     }
      65. //    生产者步骤：
      66. //            1，判断桌子上是否有汉堡包
      67. //    如果有就等待，如果没有才生产。
      68. //            2，把汉堡包放在桌子上。
      69. //            3，叫醒等待的消费者开吃。
      70. ​
      71.     @Override
      72.     public void run() {
      73.         while(true){
      74.             synchronized (desk.getLock()){
      75.                 if(desk.getCount() == 0){
      76.                     break;
      77.                 }else{
      78.                     //System.out.println("验证一下是否执行了");
      79.                     if(!desk.isFlag()){
      80.                         //生产
      81.                         System.out.println("厨师正在生产汉堡包");
      82.                         desk.setFlag(true);
      83.                         desk.getLock().notifyAll();
      84.                     }else{
      85.                         try {
      86.                             desk.getLock().wait();
      87.                         } catch (InterruptedException e) {
      88.                             e.printStackTrace();
      89.                         }
      90.                     }
      91.                 }
      92.             }
      93.         }
      94.     }
      95. }
      96. ​
      97. public class Foodie extends Thread {
      98.     private Desk desk;
      99. ​
      100.     public Foodie(Desk desk) {
      101.         this.desk = desk;
      102.     }
      103. ​
      104.     @Override
      105.     public void run() {
      106. //        1，判断桌子上是否有汉堡包。
      107. //        2，如果没有就等待。
      108. //        3，如果有就开吃
      109. //        4，吃完之后，桌子上的汉堡包就没有了
      110. //                叫醒等待的生产者继续生产
      111. //        汉堡包的总数量减一
      112. ​
      113.         //套路:
      114.             //1. while(true)死循环
      115.             //2. synchronized 锁,锁对象要唯一
      116.             //3. 判断,共享数据是否结束. 结束
      117.             //4. 判断,共享数据是否结束. 没有结束
      118.         while(true){
      119.             synchronized (desk.getLock()){
      120.                 if(desk.getCount() == 0){
      121.                     break;
      122.                 }else{
      123.                     //System.out.println("验证一下是否执行了");
      124.                     if(desk.isFlag()){
      125.                         //有
      126.                         System.out.println("吃货在吃汉堡包");
      127.                         desk.setFlag(false);
      128.                         desk.getLock().notifyAll();
      129.                         desk.setCount(desk.getCount() - 1);
      130.                     }else{
      131.                         //没有就等待
      132.                         //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
      133.                         try {
      134.                             desk.getLock().wait();
      135.                         } catch (InterruptedException e) {
      136.                             e.printStackTrace();
      137.                         }
      138.                     }
      139.                 }
      140.             }
      141.         }
      142. ​
      143.     }
      144. }
      145. ​
      146. public class Demo {
      147.     public static void main(String[] args) {
      148.         /*消费者步骤：
      149.         1，判断桌子上是否有汉堡包。
      150.         2，如果没有就等待。
      151.         3，如果有就开吃
      152.         4，吃完之后，桌子上的汉堡包就没有了
      153.                 叫醒等待的生产者继续生产
      154.         汉堡包的总数量减一*/
      155. ​
      156.         /*生产者步骤：
      157.         1，判断桌子上是否有汉堡包
      158.         如果有就等待，如果没有才生产。
      159.         2，把汉堡包放在桌子上。
      160.         3，叫醒等待的消费者开吃。*/
      161. ​
      162.         Desk desk = new Desk();
      163. ​
      164.         Foodie f = new Foodie(desk);
      165.         Cooker c = new Cooker(desk);
      166. ​
      167.         f.start();
      168.         c.start();
      169. ​
      170.     }
      171. }

    3.4阻塞队列基本使用【理解】

    • 阻塞队列继承结构

    • 常见BlockingQueue:

      ArrayBlockingQueue: 底层是数组,有界

      LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

    • BlockingQueue的核心方法:

      put(anObject): 将参数放入队列,如果放不进去会阻塞

      take(): 取出第一个数据,取不到会阻塞

    • 代码示例

      1. public class Demo02 {
      2.     public static void main(String[] args) throws Exception {
      3.         // 创建阻塞队列的对象,容量为 1
      4.         ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(1);
      5. ​
      6.         // 存储元素
      7.         arrayBlockingQueue.put("汉堡包");
      8. ​
      9.         // 取元素
      10.         System.out.println(arrayBlockingQueue.take());
      11.         System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞
      12. ​
      13.         System.out.println("程序结束了");
      14.     }
      15. }

    3.5阻塞队列实现等待唤醒机制【理解】

    • 案例需求

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

        1.构造方法中接收一个阻塞队列对象

        2.在run方法中循环向阻塞队列中添加包子

        3.打印添加结果

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

        1.构造方法中接收一个阻塞队列对象

        2.在run方法中循环获取阻塞队列中的包子

        3.打印获取结果

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

        创建阻塞队列对象

        创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象

        分别开启两个线程

    • 代码实现

      1. public class Cooker extends Thread {
      2. ​
      3.     private ArrayBlockingQueue bd;
      4. ​
      5.     public Cooker(ArrayBlockingQueue bd) {
      6.         this.bd = bd;
      7.     }
      8. //    生产者步骤：
      9. //            1，判断桌子上是否有汉堡包
      10. //    如果有就等待，如果没有才生产。
      11. //            2，把汉堡包放在桌子上。
      12. //            3，叫醒等待的消费者开吃。
      13. ​
      14.     @Override
      15.     public void run() {
      16.         while (true) {
      17.             try {
      18.                 bd.put("汉堡包");
      19.                 System.out.println("厨师放入一个汉堡包");
      20.             } catch (InterruptedException e) {
      21.                 e.printStackTrace();
      22.             }
      23.         }
      24.     }
      25. }
      26. ​
      27. public class Foodie extends Thread {
      28.     private ArrayBlockingQueue bd;
      29. ​
      30.     public Foodie(ArrayBlockingQueue bd) {
      31.         this.bd = bd;
      32.     }
      33. ​
      34.     @Override
      35.     public void run() {
      36. //        1，判断桌子上是否有汉堡包。
      37. //        2，如果没有就等待。
      38. //        3，如果有就开吃
      39. //        4，吃完之后，桌子上的汉堡包就没有了
      40. //                叫醒等待的生产者继续生产
      41. //        汉堡包的总数量减一
      42. ​
      43.         //套路:
      44.         //1. while(true)死循环
      45.         //2. synchronized 锁,锁对象要唯一
      46.         //3. 判断,共享数据是否结束. 结束
      47.         //4. 判断,共享数据是否结束. 没有结束
      48.         while (true) {
      49.             try {
      50.                 String take = bd.take();
      51.                 System.out.println("吃货将" + take + "拿出来吃了");
      52.             } catch (InterruptedException e) {
      53.                 e.printStackTrace();
      54.             }
      55.         }
      56. ​
      57.     }
      58. }
      59. ​
      60. public class Demo {
      61.     public static void main(String[] args) {
      62.         ArrayBlockingQueue bd = new ArrayBlockingQueue<>(1);
      63. ​
      64.         Foodie f = new Foodie(bd);
      65.         Cooker c = new Cooker(bd);
      66. ​
      67.         f.start();
      68.         c.start();
      69.     }
      70. }

  • 相关阅读:
    常用傅里叶变换表
    DLMS/COSEM中的信息安全：安全密钥（中）续2
    Helm3模板-控制流程
    高通骁龙8cx Gen3和骁龙8cx gen2差距
    Web3和低代码开发：下一代Web应用开发的合作与创新
    实现0.5px的线
    java+python+nodejs设备配件采购报修进销存管理系统
    乾元通多卡聚合路由器的技术解析
    element-ui对话框dialog详解
    nginx+HTTPS证书
  • 原文地址：https://blog.csdn.net/qq_69748833/article/details/133420648