java thread wait notify 线程通讯

最新推荐文章于 2026-06-22 17:43:33 发布

原创最新推荐文章于 2026-06-22 17:43:33 发布 · 307 阅读

6 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#笔记

package org.example;

public class Main {
    public static void main(String[] args) {
        Cook c = new Cook();
        Foodie f=new Foodie();

        c.setName("厨师");
        f.setName("吃货");

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


        }

}

package org.example;

public class Desk {

    //0:没有面条； 1:有面条
    public static int foodFlag = 0;
    //总个数
    public static int count=10;

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


}

package org.example;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Cook extends Thread{

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

                }
            }
            //System.out.println("厨师做了一碗面条   "+Desk.foodFlag);
            System.out.println("厨师做了一碗面条   ");
            //厨师做完面条后，还没来得及打印上面这句话，就被吃货线程先抢到锁，执行消费了；
            //消费后打印上面这句话，Desk.foodFlag是0
        }
    }
}

package org.example;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Foodie extends Thread{
    @Override
    public void run() {
        while (true){
            synchronized (Desk.lock){
                if(Desk.count==0){
                    break;
                }else{
                    //先判断桌子上是否有面条
                    while (Desk.foodFlag ==0){
                        //如果没有，就等待
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                    Desk.count--;
                    //如果有，就开吃
                    System.out.println("吃货在吃面条，还能再吃"+ Desk.count+"碗！！！");
                    //log.info("吃货在吃面条，还能再吃"+ Desk.count+"碗！！！");
                    Desk.lock.notifyAll();
                    Desk.foodFlag =0;

                }
            }
        }
    }
}

其中的一次运行结果（每次运行的结果可能不同）：
吃货在吃面条，还能再吃9碗！！！
厨师做了一碗面条
厨师做了一碗面条
吃货在吃面条，还能再吃8碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃7碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃6碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃5碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃4碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃3碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃2碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃1碗！！！
厨师做了一碗面条
吃货在吃面条，还能再吃0碗！！！

分析

时序细节（对应前几次循环）：

初始：count=10, foodFlag=0。两个线程启动，假设 Foodie 先获得锁，发现没面条，wait() 并释放锁。
厨师第一次生产：Cook 获得锁，设置 foodFlag=1，notifyAll，退出同步块。此时准备打印，但还未执行打印语句。
吃货第一次消费：Foodie 被唤醒，竞争到锁，发现 foodFlag=1，消费：count 变为 9，打印“还能再吃9碗”，设置 foodFlag=0，notifyAll，释放锁。
厨师第一次打印：此时 Cook 才执行 System.out.println，输出“厨师做了一碗面条”。（这条日志对应第一次生产，但打印在消费日志之后）
厨师第二次生产：Cook 再次循环，获得锁（因为 foodFlag=0），设置 foodFlag=1，notifyAll，退出同步块，准备打印。
厨师第二次打印：在 Foodie 竞争到锁之前，Cook 的打印语句先执行，输出第二个“厨师做了一碗面条”。（这条日志对应第二次生产）
吃货第二次消费：Foodie 获得锁，消费，打印“还能再吃8碗”。