【Java】等待唤醒机制

已于 2024-07-25 11:55:38 修改
阅读量329 收藏 1
点赞数 3
分类专栏： Java 文章标签： java 开发语言 算法
于 2024-07-23 17:29:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XiugongHao/article/details/140641807
版权

1. 等待唤醒机制(线程之间的通信)

一个线程生产,一个线程消费,不能连续生产,不能连续消费 -> 等待唤醒机制(生产者,消费者)(线程之间的通信)

方法说明
void wait()线程等待,等待的过程中线程会释放锁,需要被其他线程调用notify方法将其唤醒,重新抢锁执行
void notify()线程唤醒,一次唤醒一个等待线程;如果有多条线程等待,则随机唤醒一条等待线程
void notifyAll()唤醒所有等待线程

wait和notify方法需要锁对象调用,所以需要用到同步代码块中,而且必须是同一个锁对象

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2. 等待唤醒案例实现

/*
   count和flag可以定义成包装类
   但是要记得给count和flag手动赋值
   不然对于本案例来说,容易出现空指针异常
 */
public class BaoZiPu {
    //代表包子的count
    private int count;
    //代表是否有包子的flag
    private boolean flag;

    public BaoZiPu() {
    }

    public BaoZiPu(int count, boolean flag) {
        this.count = count;
        this.flag = flag;
    }

    /*
       getCount 改造成消费包子方法
       直接输出count
     */
    public void getCount() {
        System.out.println("消费了..............第"+count+"个包子");
    }

    /*
       setCount 改造成生产包子
       count++
     */
    public void setCount() {
        count++;
        System.out.println("生产了...第"+count+"个包子");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}


public class Product implements Runnable{
    private BaoZiPu baoZiPu;

    public Product(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (baoZiPu){
                //1.判断flag是否为true,如果是true,证明有包子,生产线程等待
                if (baoZiPu.isFlag()==true){
                    try {
                        baoZiPu.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                //2.如果flag为false,证明没有包子,开始生产
                baoZiPu.setCount();
                //3.改变flag状态,为true,证明生产完了,有包子了
                baoZiPu.setFlag(true);
                //4.唤醒消费线程
                baoZiPu.notify();
            }
        }
    }
}


public class Consumer implements Runnable{
    private BaoZiPu baoZiPu;

    public Consumer(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            synchronized (baoZiPu){
                //1.判断flag是否为false,如果是false,证明没有包子,消费线程等待
                if (baoZiPu.isFlag()==false){
                    try {
                        baoZiPu.wait();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }

                //2.如果flag为true,证明有包子,开始消费
                baoZiPu.getCount();
                //3.改变flag状态,为false,证明消费完了,没 有包子了
                baoZiPu.setFlag(false);
                //4.唤醒生产线程
                baoZiPu.notify();
            }
        }
    }
}


public class Test01 {
    public static void main(String[] args) {
        BaoZiPu baoZiPu = new BaoZiPu();

        Product product = new Product(baoZiPu);
        Consumer consumer = new Consumer(baoZiPu);

        Thread t1 = new Thread(product);
        Thread t2 = new Thread(consumer);

        t1.start();
        t2.start();
    }
}

3. 用同步方法改造等待唤醒案例

/*
   count和flag可以定义成包装类
   但是要记得给count和flag手动赋值
   不然对于本案例来说,容易出现空指针异常
 */
public class BaoZiPu {
    //代表包子的count
    private int count;
    //代表是否有包子的flag
    private boolean flag;

    public BaoZiPu() {
    }

    public BaoZiPu(int count, boolean flag) {
        this.count = count;
        this.flag = flag;
    }

    /*
       getCount 改造成消费包子方法
       直接输出count
     */
    public synchronized void getCount() {
        //1.判断flag是否为false,如果是false,证明没有包子,消费线程等待
        if (this.flag == false) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        //2.如果flag为true,证明有包子,开始消费
        System.out.println("消费了..............第" + count + "个包子");

        //3.改变flag状态,为false,证明消费完了,没 有包子了
        this.flag = false;
        //4.唤醒生产线程
        this.notify();
    }

    /*
       setCount 改造成生产包子
       count++
     */
    public synchronized void setCount() {
        //1.判断flag是否为true,如果是true,证明有包子,生产线程等待
        if (this.flag == true) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        //2.如果flag为false,证明没有包子,开始生产
        count++;
        System.out.println("生产了...第" + count + "个包子");
        //3.改变flag状态,为true,证明生产完了,有包子了
        this.flag = true;
        //4.唤醒消费线程
        this.notify();
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}


public class Product implements Runnable{
    private BaoZiPu baoZiPu;

    public Product(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            baoZiPu.setCount();
        }
    }
}


public class Consumer implements Runnable{
    private BaoZiPu baoZiPu;

    public Consumer(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            baoZiPu.getCount();
        }
    }
}


public class Test01 {
    public static void main(String[] args) {
        BaoZiPu baoZiPu = new BaoZiPu();

        Product product = new Product(baoZiPu);
        Consumer consumer = new Consumer(baoZiPu);

        Thread t1 = new Thread(product);
        Thread t2 = new Thread(consumer);

        t1.start();
        t2.start();
    }
}

4. 多等待多唤醒

1. 解决多生产多消费问题

if 改为 while, 将 notify 改为 notifyAll

public class Test01 {
    public static void main(String[] args) {
        BaoZiPu baoZiPu = new BaoZiPu();

        Product product = new Product(baoZiPu);
        Consumer consumer = new Consumer(baoZiPu);

        new Thread(product).start();
        new Thread(product).start();
        new Thread(product).start();

        new Thread(consumer).start();
        new Thread(consumer).start();
        new Thread(consumer).start();
    }
}


/*
   count和flag可以定义成包装类
   但是要记得给count和flag手动赋值
   不然对于本案例来说,容易出现空指针异常
 */
public class BaoZiPu {
    //代表包子的count
    private int count;
    //代表是否有包子的flag
    private boolean flag;

    public BaoZiPu() {
    }

    public BaoZiPu(int count, boolean flag) {
        this.count = count;
        this.flag = flag;
    }

    /*
       getCount 改造成消费包子方法
       直接输出count
     */
    public synchronized void getCount() {
        //1.判断flag是否为false,如果是false,证明没有包子,消费线程等待
        while (this.flag == false) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        //2.如果flag为true,证明有包子,开始消费
        System.out.println("消费了..............第" + count + "个包子");

        //3.改变flag状态,为false,证明消费完了,没 有包子了
        this.flag = false;
        //4.唤醒所有等待线程
        this.notifyAll();
    }

    /*
       setCount 改造成生产包子
       count++
     */
    public synchronized void setCount() {
        //1.判断flag是否为true,如果是true,证明有包子,生产线程等待
        while (this.flag == true) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }

        //2.如果flag为false,证明没有包子,开始生产
        count++;
        System.out.println("生产了...第" + count + "个包子");
        //3.改变flag状态,为true,证明生产完了,有包子了
        this.flag = true;
        //4.唤醒所有等待线程
        this.notifyAll();
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}


public class Product implements Runnable{
    private BaoZiPu baoZiPu;

    public Product(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            baoZiPu.setCount();
        }
    }
}


public class Consumer implements Runnable{
    private BaoZiPu baoZiPu;

    public Consumer(BaoZiPu baoZiPu) {
        this.baoZiPu = baoZiPu;
    }

    @Override
    public void run() {
        while(true){

            try {
                Thread.sleep(100L);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            baoZiPu.getCount();
        }
    }
}

秀秀_heo
关注
专栏目录
Java 等待唤醒机制
01-13
Java 等待唤醒机制，适合入门者学习的demo，可下载学习。
简单了解java等待唤醒机制原理及使用
08-25
Java等待唤醒机制是一种用于解决多线程间协作和同步问题的方法，它可以帮助避免循环等待问题，提高程序效率。本文将详细介绍等待唤醒机制的原理、使用方法，并通过具体示例进行说明。 一、循环等待问题 在Java编程...
java 线程等待与唤醒
Code-lover's Learning Notes
08-09 1544
概要 本章，会对线程等待/唤醒方法进行介绍。涉及到的内容包括： 1. wait(), notify(), notifyAll()等方法介绍 2. wait()和notify() 3. wait(long timeout)和notify() 4. wait() 和 notifyAll() 5. 为什么notify(), wait()等函数定义在Object中，而不是Thread中
浅谈JAVA中等待唤醒机制
adair_moringstar的博客
08-01 308
等待唤醒机制 1.线程间通信 概念：多个线程在处理同⼀个资源，但是处理的动作（线程的任务）却不相同。 比如：线程A用来生成包子的，线程B⽤来吃包子的，包子可以理解为同⼀资源，线程A与线程B处理的动作，⼀个是生产，⼀个是消费，那么线程A与线程B之间就存在线程通信问题。 为什么要处理线程间通信： 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成⼀件任务，并且我们希望他们有规律的执行，那么多线程之间需要⼀些协调通信，以此来帮我们达到多线程共同操作⼀份数据。 如何保证线程间通信
三步教你懂得线程间通信
Firework_han的博客
11-06 368
三步教你懂得线程间通信
Java 中的等待唤醒机制
weixin_57219176的博客
05-03 422
* 生产者消费者模式: * * Student类: * 公共的字段:姓名和年龄(学生数据) * SetThread类:生产者线程 * 产生学生数据 * GetThread类:消费者线程 * 消费学生数据 * * * StudentDemo类:主线程(用户线程): 开启生产者线程和消费者线程! * * 问题1:消费者所在的线程和生产者所在的线程操作不是同一个资源对象 ...
Java 等待唤醒机制 代码优化
01-14
在Java编程中，线程的等待唤醒机制是多线程编程中的重要概念，它涉及到如何有效地协调多个线程之间的交互，以确保程序的正确运行。本文将深入探讨这个主题，并提供一些代码优化的建议，适合Java初学者进行学习和参考...
Java等待唤醒机制线程通信原理解析
08-25
主要介绍了Java等待唤醒机制线程通信原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java等待唤醒机制
10-03
Java的等待唤醒机制是一种线程间的通信机制，用于实现线程之间的同步和协作。它通过使用Object类的wait()和notify()/notifyAll()方法来实现。 具体来说，当一个线程调用对象的wait()方法时，它会释放对象的锁并进入...
Java 等待/唤醒机制
china_demon的专栏
01-30 593
package day14; /*  * 等待/唤醒机制  * 涉及的方法：  * 1、wait();让线程处于冻结状态，被wait的线程会被存储到线程池中。  * 2、notify();唤醒线程池中一个线程（任意）。  * 3、notifyAll()：唤醒线程池中的所有线程。  *   * 这些方法都必须定义在同步中。  * 因为这些方法是用于操作线程状态的方法。  * 必须
Java中等待唤醒机制
scbiaosdo的博客
05-30 1409
使用的是继承自Object的两个方法public final void wait() throws InterruptedException线程等待public final void notify()唤醒在此对象监视器上等待的单个线程自定义类，定义信息public class People { String name ; int age ; boolean...
【Java】生产者和消费者（等待唤醒机制）
最新发布
qq_39921135的博客
07-15 1170
但是光有它们两个还不够，还需要有第三者桌子，因为在默认情况下，线程的执行是具有随机性的，我们需要有一个东西去控制线程的执行，现在我们就用桌子去控制。假设在一开始，不是厨师先抢到CPU的执行权，而是吃货先抢到CPU的执行权，这个时候桌子上还没有东西的，总不能啃桌子吧，所以它只能先等着，代码中叫做。此时厨师已经等着了，一旦它等待，CPU的执行权就会被吃货抢走，吃货就会执行我们刚刚推导的两步，它会去判断桌子上是否有事物，没有事物就会等待。如果你写完代码，这里的红灯没有灭，那么你的代码就是有bug的。
Java等待唤醒机制
绝望的灰太狼的博客
03-17 220
等待和唤醒机制 线程间的通信，多个线程处理同一资源 多线程在并发执行时，CPU是随机切换的，我们需要让他有规律的执行 多个线程的协调通信，以此来达到共同操作统一资源，避免对同一变量的争夺。 生产者与消费者之间的关系 多个线程之间的协作机制: 资源类，属性 ================ /* * 包子类: * 资源类 * 设置包子属性 * 皮 * 馅 * ...
Java学习-等待唤醒机制（一）
qq_44813352的博客
02-23 201
线程状态概述 等待唤醒案例分析 等待唤醒案例代码实现 /* 等待唤醒案例:线程之间的通信 创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待) 创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子 注意: 顾客...
Java——等待唤醒机制（wait和notify）生产者消费者问题
程序员阿龙的博客
08-02 1506
Java——等待唤醒机制（wait和notify）生产者消费者问题
java学习(等待唤醒)
qq_41302368的博客
07-18 430
等待唤醒机制 线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。通过一定的手段使各个线程能有效的利用资源。而这种手段即—— 等待唤醒机制。 等待唤醒机制所涉及到的方法： 1、wait（） :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。 2、notify（）：唤醒，唤醒线程池中被wait（）的线程，一次唤醒一个，而且是任意的。 3、notifyA...
java 等待 唤醒_java等待唤醒机制
weixin_35944230的博客
02-12 86
classInputOutputDemo{publicstaticvoidmain(String[]args){Resr=newRes();Inputi=newInput(r);Outputo=newOutput(r);Threadt=newThread(i);Threadt1=newThread(o);t.start();t1.star...class InputOutputDemo{publi...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秀秀_heo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值