『JAVA多线程·学习之路』-生产者消费者问题（有代码实现）

不念不忘少年蓝@ 2023-09-28 23:26 17阅读 0赞

#### 生产者与消费者 ####

*   *  最理想的情况
     *  两个异常情况
     *   *  第一个
         *  第二个
     *  生产者消费者代码实现
     *   *  消费者代码实现
         *  生产者代码实现
         *  Desk代码实现
         *  启动线程，运行结果
         *  <消费者代码改写>
         *  <生产者代码改写>
         *  <Desk代码改写>
         *  启动线程

**生产者消费者模式概述**

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

### 最理想的情况 ###

一开始，生产者先抢到CPU的执行权，然后他生产了一个汉堡包，然后将汉堡包放在了桌子上，此时桌子上有了一个汉堡包。  
![生产者][8b6d892b55d843ea9dbb19982de8795b.gif]  
然后消费者抢到了CPU的执行权，这时他就要从桌子上拿走汉堡包去吃。  
![消费者][578b2780e7bf40c38a3afd98fc55024b.gif]  
然后一直循环下去，两个线程轮流执行，你一次我一次。

### 两个异常情况 ###

#### 第一个 ####

**消费者等待过程：**

消费者先抢到CPU执行权，去吃，发现桌子上没东西，他就要开始等待，这个时候，厨师线程抢到执行权，他就去生产汉堡包，生产完了将汉堡包放在桌子上，放下之后他就会通知消费者，这个时候消费者才开始吃。

**消费者步骤：**

1.判断桌子上是否有汉堡包。

2.如果没有就等待。

**生产者步骤：**

1.生产汉堡包

2.把汉堡包放在桌子上

3.叫醒等待的消费者开饭

#### 第二个 ####

**生产者等待过程：**

生产者先抢到CPU的执行权，他就开始做汉堡包，做完之后将汉堡包放在桌子上，下面还是厨师线程抢到CPU执行权，这个时候生产者不再生产汉堡包，他就开始等待，等消费者去吃。接下来等消费者抢到了CPU的执行权，然后 **消费者判断桌子上是否有汉堡包** 如果有就直接开吃，吃完之后，桌子上没有了汉堡包，然后叫醒等待的生产者继续生产。

**改写消费者步骤：**

1.判断桌子上是否有汉堡包

2.如果没有就等待

3.如果有就开吃

4.吃完之后，桌子上的汉堡包就没有了，叫醒等待的生产者继续生产，汉堡包的总数量-1

**改写生产者步骤：**

1.判断桌子上是否有汉堡包，如果有就等待，如果没有才生产

2.把汉堡包放在桌子上

3.叫醒等待的消费者开吃

### 生产者消费者代码实现 ###

**等待和唤醒的方法**

Java提供了几个方法供我们使用，这几个方法在Object类中

<table> 
 <thead> 
  <tr> 
   <th align="center">方法名</th> 
   <th align="center">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">void wait()</td> 
   <td align="center">导致当前线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法</td> 
  </tr> 
  <tr> 
   <td align="center">void notify()</td> 
   <td align="center">唤醒正在等待对象监视器的单个线程</td> 
  </tr> 
  <tr> 
   <td align="center">void notifyAll()</td> 
   <td align="center">唤醒正在等待对象监视器的所有线程</td> 
  </tr> 
 </tbody> 
</table>

#### 消费者代码实现 ####

public class Foodie extends Thread{
        @Override
        public void run() {
    /*        1.判断桌子上是否有汉堡包
            2.如果没有就等待
            3.如果有就开吃
            4.吃完之后，桌子上的汉堡包就没有了，
            叫醒等待的生产者继续生产，汉堡包的总数量-1*/
            while (true){
                synchronized (Desk.lock){
                    if(Desk.count == 0){
                        break;
                    }else {
                        if(Desk.flag){
                            //有
                            System.out.println("消费者在吃汉堡包");
                            Desk.flag = false;//汉堡包没有了
                            Desk.lock.notifyAll();
                            Desk.count--;
                        }else {
                            //没有就等待
                            //使用什么对象当作锁，那么就必须用这个对象去调用等待和取消等待方法
                            try {
                                Desk.lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }

#### 生产者代码实现 ####

public class Cooker extends Thread{
        @Override
        public void run() {
    //        1.判断桌子上是否有汉堡包，如果有就等待，如果没有才生产
    //        2.把汉堡包放在桌子上
    //        3.叫醒等待的消费者开吃
            while (true){
                synchronized (Desk.lock){
                    if(Desk.count == 0){
                        break;
                    }else {
                        if(!Desk.flag){
                            //生产
                            System.out.println("厨师正在生产汉堡包");
                            Desk.flag = true;
                            Desk.lock.notifyAll();
                        }else {
                            try {
                                Desk.lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }

#### Desk代码实现 ####

public class Desk {
        //定义一个标记
        //true 就表示桌子上有汉堡包，则允许消费者执行
        //false 就表示座子上没有汉堡包，此时允许生产者执行
    //    public static boolean flag = false;
    
    
        //汉堡包的总数量
    //    public static int count = 10;
    
    
        //锁对象
    //    public static final Object lock = new Object();
    
    }

**小tips：** 写多线程代码套路

//套路：
    //1.while(true)死循环
    //2.synchronized锁，锁对象要唯一
    //3.判断，共享数据是否结束，结束
    //4.判断，判断共享数据是否结束，没有结束

#### 启动线程，运行结果 ####

厨师正在生产汉堡包
    消费者在吃汉堡包
    厨师正在生产汉堡包
    消费者在吃汉堡包
    ...
    厨师正在生产汉堡包
    消费者在吃汉堡包
    
    Process finished with exit code 0

一个生产一个吃，顺序循环。

#### <消费者代码改写> ####

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){
                synchronized (desk.getLock()){
                    if(desk.getCount() == 0){
                        break;
                    }else {
                        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 Cooker extends Thread{
        private Desk desk;
        public Cooker(Desk desk) {
            this.desk = desk;
        }
    
        @Override
        public void run() {
    //        1.判断桌子上是否有汉堡包，如果有就等待，如果没有才生产
    //        2.把汉堡包放在桌子上
    //        3.叫醒等待的消费者开吃
            while (true){
                synchronized (desk.getLock()){
                    if(desk.getCount()== 0){
                        break;
                    }else {
                        if(!desk.isFlag()){
                            //生产
                            System.out.println("厨师正在生产汉堡包");
                            desk.setFlag(true);
                            desk.getLock().notifyAll();
                        }else {
                            try {
                                desk.getLock().wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }
        }
    }

#### <Desk代码改写> ####

public class Desk {
        //定义一个标记
        //true 就表示桌子上有汉堡包，则允许消费者执行
        //false 就表示座子上没有汉堡包，此时允许生产者执行
    //    public static boolean flag = false;
        private boolean flag;
    
        //汉堡包的总数量
    //    public static int count = 10;
        //以后我们在使用这种必须有默认值的变量
        private int count = 10;
    
        //锁对象
    //    public static final Object lock = new Object();
        private final Object lock = new Object();
    
        public Desk() {
        }
    
        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 +
                    '}';
        }
    }

#### 启动线程 ####

Desk desk = new Desk();
    
    Foodie f = new Foodie(desk);
    Cooker c = new Cooker(desk);
    
    f.start();
    c.start();

结果正常

[56f30414b5c44ec087bfe528b8af1e6d.png]: https://img-blog.csdnimg.cn/56f30414b5c44ec087bfe528b8af1e6d.png
[8b6d892b55d843ea9dbb19982de8795b.gif]: https://img-blog.csdnimg.cn/8b6d892b55d843ea9dbb19982de8795b.gif
[578b2780e7bf40c38a3afd98fc55024b.gif]: https://img-blog.csdnimg.cn/578b2780e7bf40c38a3afd98fc55024b.gif