多线程的等待唤醒机制的自我理解

public class Desk {
    //共享的数据
    public static int foodFlag=0;//表示桌面上是否有面条 0表示没有面条 1表示有面条
    public static int count=10;//表示面条的总个数
    public static Object lock=new Object();//锁
 
 
}

public class Foodie 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) {
                            throw new RuntimeException(e);
                        }
                    }
                    else {
                        //有面条 吃货得吃掉面条
                        System.out.println("吃货吃了面条,还能再吃"+(Desk.count-1)+"碗");
                        //唤醒厨师
                        Desk.lock.notifyAll();
                        //总数减去1
                        Desk.count--;
                        //修改桌子的状态 此时是没有面条的了
                        Desk.foodFlag=0;
                    }
                }
            }
        }
    }
}

public class Cook 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();
                    }
                }
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        //创建线程
        Foodie f=new Foodie();
        Cook c=new Cook();
 
        //给线程设置名字
        f.setName("吃货");
        c.setName("厨师");
 
        //一起启动
        f.start();
        c.start();
    }
}

import java.util.concurrent.ArrayBlockingQueue;
public class Cook extends Thread{
    ArrayBlockingQueue<String>queue;
 
    //生成构造函数 创建对象的时候给queue赋值
    public Cook(ArrayBlockingQueue<String> queue) {
        this.queue = queue;
    }
 
    @Override
    public void run() {
        //不断的从阻塞队列中添加面条
        while (true){
            try {
                queue.put("面条");
                System.out.println("厨师放了一碗面条");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;
public class Foodie extends Thread{
    ArrayBlockingQueue<String> queue;
 
    //生成构造函数 创建对象的时候给queue赋值
    public Foodie(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();
            }
        }
    }
}

import javax.crypto.spec.PSource;
import java.util.concurrent.ArrayBlockingQueue;
 
public class Main {
    public static void main(String[] args) {
        //阻塞队列的对象创建在测试类里面
        //有界的阻塞队列 创建对象的时候指定上限
        ArrayBlockingQueue<String>queue=new ArrayBlockingQueue<>(1);
 
        //创建线程对象 并且把阻塞队列传递过去
        Cook c=new Cook(queue);
        Foodie f=new Foodie(queue);
 
        c.start();
        f.start();
    }
}