Java多线程之等待唤醒机制及案例代码演示

柔光的暖阳◎ 2024-02-25 03:55 48阅读 0赞

#### 生产者和消费者（等待唤醒机制） ####

*  等待唤醒机制
 *  常见方法
 *  代码演示
 *  等待唤醒机制(阻塞队列方式实现)
 *  额外扩展

## 等待唤醒机制 ##

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

举个小栗子来说明一下消费者和生产者的等待唤醒过程:  
![在这里插入图片描述][fe79b755aec543769d31ddc9e3e58f6f.png]

## 常见方法 ##

*  void wait() 当前线程等待，直到被其他线程唤醒
 *  void notify() 随机唤醒单个线程
 *  void notifyAll() 唤醒所有线程

![在这里插入图片描述][76ca2c107d13428fb746bf7a104f342a.png]

## 代码演示 ##

接下来，使用代码来演示生产者和消费者的等待唤醒过程

**1、消费者代码：**

package com.heima.thread001;
    
    public class FoodThread extends Thread {
        
    
        @Override
        public void run() {
        
            while (true){
        
                synchronized (Desk.lock){
        
                    if (Desk.count == 0){
        
                        break;
                    }else {
        
                        //判断桌子上有没有面条
                        if (Desk.foodFlag == 0){
        
                            //如果没有，就等待
                            try {
        
                                Desk.lock.wait();//让当前线程跟锁进行绑定
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();
                            }
                        }else {
        
                            //把吃的总数-1
                            Desk.count--;
                            //如果有，就开吃
                            System.out.println("吃货在吃面条，还能再吃" + Desk.count + "碗");
                            //吃完之后，唤醒厨师继续做
                            Desk.lock.notifyAll();
                            //修改桌子的状态
                            Desk.foodFlag = 0;
                        }
                    }
                }
            }
        }
    }

**2、生产者代码**

package com.heima.thread001;
    
    public class CookThread extends Thread {
        
    
        @Override
        public void run() {
        
            while (true){
        
                synchronized (Desk.lock){
        
                    //判断桌子上有没有面条
                    if (Desk.count == 0){
        
                        break;
                    }else {
        
                        //判断桌子上是否有实物
                        if(Desk.foodFlag == 1){
        
                            //如果有，就等待
                            try {
        
                                Desk.lock.wait();
                            } catch (InterruptedException e) {
        
                                e.printStackTrace();
                            }
                        }else {
        
                            //如果没有，就制作面条
                            System.out.println("厨师做了一碗面条");
                            //修改桌子上的食物状态
                            Desk.foodFlag = 1;
                            //叫醒等待的消费者开吃
                            Desk.lock.notifyAll();
                        }
                    }
                }
            }
        }
    }

**3、控制生产者和消费者的执行类**

package com.heima.thread001;
    
    public class Desk {
        
    
        /**
         * 作用：控制生产者和消费者的执行
         */
    
        //是否有面条  0：没有面条  1：有面条
        public static int foodFlag = 0;
    
        //总个数
        public static int  count = 10;
    
        //锁对象
        public static Object lock = new Object();
    }

**4、测试类**

package com.heima.thread001;
    
    public class TestDemo {
        
        public static void main(String[] args){
        
    
            CookThread cookThread = new CookThread();
            FoodThread foodThread = new FoodThread();
    
            cookThread.setName("厨师");
            foodThread.setName("吃货");
    
            cookThread.start();
            foodThread.start();
        }
    }

**5、运行结果**

Connected to the target VM, address: '127.0.0.1:52025', transport: 'socket'
    Disconnected from the target VM, address: '127.0.0.1:52025', transport: 'socket'
    厨师做了一碗面条
    吃货在吃面条，还能再吃9碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃8碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃7碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃6碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃5碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃4碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃3碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃2碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃1碗
    厨师做了一碗面条
    吃货在吃面条，还能再吃0碗
    
    Process finished with exit code 0

## 等待唤醒机制(阻塞队列方式实现) ##

![在这里插入图片描述][9f5be8d4ecd5419db49b4913b94c8b3b.png]  
阻塞队列的继承结构  
![在这里插入图片描述][5b6006513b984058bc687a45f4eaf393.png]  
**代码演示：**  
生产者代码

package com.heima.thread001;
    
    import java.util.concurrent.ArrayBlockingQueue;
    
    public class CookThread extends Thread {
        
    
        ArrayBlockingQueue<String> queue;
    
        public CookThread(ArrayBlockingQueue<String> queue){
        
            this.queue = queue;
        }
        @Override
        public void run() {
        
            while (true){
        
                //不断把面条放到阻塞队列中
                try {
        
                    queue.put("面条");
                    System.out.println("厨师放了一碗面条");
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

消费者

package com.heima.thread001;
    
    import java.util.concurrent.ArrayBlockingQueue;
    
    public class FoodThread extends Thread {
        
    
        ArrayBlockingQueue<String> queue;
    
        public FoodThread(ArrayBlockingQueue<String> queue){
        
            this.queue = queue;
        }
        @Override
        public void run() {
        
            while (true){
        
                //不断的从阻塞队列中获取面条
                try {
        
                    String food = queue.take();
                    System.out.println(food);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

测试类

package com.heima.thread001;
    
    import java.util.concurrent.ArrayBlockingQueue;
    
    public class TestDemo {
        
        public static void main(String[] args){
        
    
            ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
            CookThread c = new CookThread(queue);
            FoodThread f = new FoodThread(queue);
    
            c.start();
            f.start();
        }
    }

## 额外扩展 ##

**wait()、notify()、notifyAll()方法**  
Object类里面提供了这几个方法：  
wait()：让当前线程处于等待（阻塞状态），直到其他线程调用此对象的notify()或notifyAll()方法（进入就绪状态）。  
notify()：唤醒在此对象监视器上等待的单个线程。  
notifyAll()：唤醒在此对象监视器上等待的所有线程。  
每个方法都有finnal关键字修饰。

**为什么这些方法要定义在Object类里，而不定义在Thread类里呢？**  
因为这些方法的调用必须通过锁对象调用，而锁对象可以是任意对象。所以定义在Object类里。

[fe79b755aec543769d31ddc9e3e58f6f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/507e83f64a87441c9a761e066d0ec73c.png
[76ca2c107d13428fb746bf7a104f342a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/f5683bf90cac458cbc18f5b8298c1d5c.png
[9f5be8d4ecd5419db49b4913b94c8b3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/ed63f88dc30d49c8b7054355820dd797.png
[5b6006513b984058bc687a45f4eaf393.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/25/f199dd6c3d4e4db09921271e4338d111.png