Java多线程生产者消费者说明等待唤醒机制问题和虚假唤醒问题

最新推荐文章于 2025-03-22 21:43:44 发布
最新推荐文章于 2025-03-22 21:43:44 发布
阅读量1.9k 收藏 3
点赞数 1
分类专栏： 多线程 文章标签： java string 多线程 等待唤醒 虚假唤醒
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/bug_moving/article/details/60765233
版权

不用等待唤醒机制实现的生产者与消费者

代码

package com.hust.juc;

/*
 * 生产者和消费者案例
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Productor pro = new Productor(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者 A").start();
        new Thread(cus, "消费者 B").start();

        /*
         * new Thread(pro, "生产者 C").start(); new Thread(cus, "消费者 D").start();
         */
    }

}

// 店员
class Clerk {
    private int product = 0;

    // 进货
    public synchronized void get() {// 循环次数：0
        if (product >= 1) {
            System.out.println("产品已满！");

            /*try {
                this.wait();
            } catch (InterruptedException e) {
            }*/

        } else {
            System.out.println(Thread.currentThread().getName() + " : "
                    + ++product);
            //this.notifyAll();
        }

    }

    // 卖货
    public synchronized void sale() {// product = 0; 循环次数：0
        if (product <= 0) {
            System.out.println("缺货！");

            /*try {
                this.wait();
            } catch (InterruptedException e) {
            }*/
        } else {
            System.out.println(Thread.currentThread().getName() + " : "
                    + --product);
            //this.notifyAll();
        }
    }
}

// 生产者
class Productor implements Runnable {
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }

            clerk.get();
        }
    }
}

// 消费者
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

运行结果

这里写图片描述

只要线程得到了CPU就会运行，缺货也会一直去缺货，很不科学，所以这个时候我们得用等待唤醒机制。

使用等待唤醒机制

代码

就是把上面的代码中await和notify的注释打开

运行结果

这里写图片描述

这个时候会发现都运行完了，但是程序并没有结束，这就是等待唤醒机制遗留问题。

解决等待唤醒机制的问题

我们分析一下，很容易想到是因为，await被唤醒之后是从await的地方继续执行，那么直接从else出走掉了，假如那是消费者的最后一轮循环，那么那个最后一轮循环的线程就结束了，生产者还有一轮或者多伦循环没有结束，生产者线程生产出的商品就没有线程去消费就会一直等待。

代码去掉else就解决了这个问题

package com.hust.juc;

/*
 * 生产者和消费者案例
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Productor pro = new Productor(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者 A").start();
        new Thread(cus, "消费者 B").start();

        /*
         * new Thread(pro, "生产者 C").start(); new Thread(cus, "消费者 D").start();
         */
    }

}

// 店员
class Clerk {
    private int product = 0;

    // 进货
    public synchronized void get() {// 循环次数：0
        if (product >= 1) {
            System.out.println("产品已满！");

            try {
                this.wait();
            } catch (InterruptedException e) {
            }

        }

        System.out
                .println(Thread.currentThread().getName() + " : " + ++product);
        this.notifyAll();
    }

    // 卖货
    public synchronized void sale() {// product = 0; 循环次数：0
        if (product <= 0) {
            System.out.println("缺货！");

            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }

        System.out
                .println(Thread.currentThread().getName() + " : " + --product);
        this.notifyAll();
    }
}

// 生产者
class Productor implements Runnable {
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }

            clerk.get();
        }
    }
}

// 消费者
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

多线程下的虚假唤醒

说白了其实这还是“单线程“，因为只有一个线程生产一个线程消费，如果现在有两个线程去生产，两个线程去消费，那么就会出现虚假唤醒的情况。

虚假唤醒代码

把上面的代码中CD线程注释掉的打开就行。

运行截图

这里写图片描述

虚假唤醒问题分析

仔细考虑一下，假如现在消费者线程C执行，此时没有商品，消费者线程C等待，这个时候消费者线程D也拿到了CPU，也是没有商品的状态，也等待。这个时候一个生产者生产出了一个商品，此时唤醒了两个等待的消费者，往下执行，那么很自然就产生了-1等负数的情况。

解决办法就是把wait放在循环里

package com.hust.juc;

/*
 * 生产者和消费者案例
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Productor pro = new Productor(clerk);
        Consumer cus = new Consumer(clerk);

        new Thread(pro, "生产者 A").start();
        new Thread(cus, "消费者 B").start();

        new Thread(pro, "生产者 C").start();
        new Thread(cus, "消费者 D").start();

    }
}

// 店员
class Clerk {
    private int product = 0;

    // 进货
    public synchronized void get() {// 循环次数：0
        while (product >= 1) {
            System.out.println("产品已满！");

            try {
                this.wait();
            } catch (InterruptedException e) {
            }

        }

        System.out
                .println(Thread.currentThread().getName() + " : " + ++product);
        this.notifyAll();
    }

    // 卖货
    public synchronized void sale() {// product = 0; 循环次数：0
        while (product <= 0) {
            System.out.println("缺货！");

            try {
                this.wait();
            } catch (InterruptedException e) {
            }
        }

        System.out
                .println(Thread.currentThread().getName() + " : " + --product);
        this.notifyAll();
    }
}

// 生产者
class Productor implements Runnable {
    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }

            clerk.get();
        }
    }
}

// 消费者
class Consumer implements Runnable {
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }
}

运行截图

这里写图片描述

这个才会得到解决。

Java 多线程 唤醒中的 虚假唤醒
norang的博客
10-30 310
这里写目录标题synchronized 版本，双线程，生产者消费者运行结果synchronized 版本，四线程， 生产者消费者运行结果这里，居然，卡住了，不知道为啥synchronized 版本，四线程， 生产者消费者，使用 while 判断运行结果总结参考目录 synchronized 版本，双线程，生产者消费者 public class 虚假唤醒 { public static void main(String[] args) { Data data=new Data();
Java多线程之虚假唤醒（原创）
Cratels学编程
03-31 2168
Java多线程之虚假唤醒 文章目录Java多线程之虚假唤醒虚假唤醒的定义从`生产者-消费者`场景讲起单生产者-单消费者场景多生产者-多消费者场景这就是虚假唤醒吗？ 首先需要说明的是，虚假唤醒不是Java语言特有的问题，而是多线程通信特有的问题，在java中就体现在sychronized-wait-notify上，最典型的应用场景就是生产者-消费者模式。 在网上翻看了很多关于虚假唤醒的文档，才发现大多数人说的都是错的。要么语焉不详，要么南辕北辙，不一而足。于是我决定自己写一篇文章来说一说：到底什么是虚假唤醒？
java线程虚假唤醒_JAVA线程虚假唤醒
weixin_33893979的博客
02-16 185
JAVA线程虚假唤醒线程虚假唤醒问题描述​ 在JDK API文档中，关于Object类的wait()方法有这样一句话描述"线程也可以唤醒，而不会被通知，中断或超时，即所谓的虚假唤醒 。 虽然这在实践中很少会发生，但应用程序必须通过测试应该使线程被唤醒的条件来防范，并且如果条件不满足则继续等待"，如下图所示： ​ 在多线程的情况下，当多个线程执行了wait()方法后，需要其它线程执行notify()...
Java锁等待唤醒机制
最新发布
qq_56323274的博客
03-22 466
在 Java 并发编程中，锁的等待和唤醒机制至关重要，通常使用 wait()、notify() 和 notifyAll() 来实现线程间的协调。本文将详细介绍这些方法的用法，并通过示例代码加以说明。
java多线程生产者消费者案例、虚假唤醒问题
qq_43460095的博客
08-26 240
package com.producersAndConsumers; public class Test { public static void main(String[] args) { SalesPerson salesPerson = new SalesPerson(); Product product = new Product(salesPerson); Consumer consumer = new Consumer(salesPers
Java线程虚假唤醒
weixin_49050715的博客
07-13 449
文章目录什么是虚假唤醒为什么会出现虚假唤醒解决的方法 #什么是虚假唤醒 #为什么会出现虚假唤醒 #解决的方法 什么是虚假唤醒 如图，JavaJdk10API文档这样描述 意思就是说线程可以在没有被通知，中断或者超时的情况下被唤醒，这就是所谓的虚假唤醒 为什么会出现虚假唤醒 1.当Object.wait()这个方法运行时，当前的线程会进入等待状态，并自动释放锁。当被其他线程唤醒时，它会在wait()之后的地方继续开始运行 2.当Object.notifyAll运行时，会唤醒所有处于等待状态的线程同时进行抢
java线程虚假唤醒
Never too late!
04-05 1550
public class MyStack {           private List list = new ArrayList();                  public synchronized void push(String value) {               synchronized (this) {                   list.add
多线程：Java多线程的等待唤醒机制代码演示通俗易懂分享给需要的同学
11-12
在多线程编程中，线程间的同步控制是一个非常重要的问题，尤其是在涉及到生产者和消费者这种协作模式时。生产者和消费者问题是一个典型的线程同步问题，其中生产者线程负责生产资源，而消费者线程则负责消费这些资源...
Java多线程技术~生产者和消费者问题
热门推荐
qq_41424688的博客
06-16 3万+
Java多线程技术~生产者和消费者问题 本文是上一篇文章的后续,详情点击该连接 线程通信 应用场景：生产者和消费者问题        假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费        如果仓库中没有产品，则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止    &
线程同步、异步、互斥、虚假唤醒和生产者消费者模式的Java&Python实现
catch_dreamer的博客
11-02 508
1、概述 生产者消费者设计模式是一个典型的线程同步问题，其主要描述的场景是一个模块生产数据或者产生数据，另一个模块用于读取或者说处理数据，一般来讲，还会有一个缓冲区，用来保存生产模块产生出来的数据。 其相关的模型如下所示： 其中缓冲区的作用是主要有以下几个： 解耦合：如上图，如果没有缓冲区，生产者将直接调用消费者中的相关方法，那么生产者模块将会对消费者模块产生依赖，也就是耦合。 支持并发：由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有执行完成之前，生产者只能一直处于等待状态。如果消费者处理数据
浅谈Java中生产者与消费者问题的演变
08-26
在Java编程中，生产者与消费者问题是多线程环境下的一个经典同步问题，涉及到如何有效地协调生产者线程（生产数据）和消费者线程（消费数据）之间的操作。这个问题的核心是确保数据的正确生产和消费，同时避免资源的...
多线程之虚假唤醒
weixin_30312563的博客
09-02 180
　今天看JDK文档中的Object.wait()方法，有一段提到： 　对于某一个参数的版本，实现中断和虚假唤醒是可能的，而且此方法应始终在循环中使用： synchronized (obj) { while (<condition does not hold>) obj.wait(); ... // Perform action appropriate to cond...
生产者消费者——虚假唤醒
笔记
03-11 153
/* * 生产者和消费者案例 */ public class TestProductorAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor pro = new Productor(clerk); Consumer cus = new Cons...
JUC-7.生产者消费者案例-虚假唤醒
xbliu564的博客
03-11 492
1. 生产者和消费者案例 以下为生产者和消费者共享店员进行进货和售货的案例，生产者在库存已满时也不停进货，消费者在库存为0时也不停售货。 那么在实际生产中，就会造成生产者在库存已满时进货，造成数据丢失。消费者也会在不停的消费。 /** * 生产者和消费者案例 * @author xiaobin * @date 2018/3/11 */ public class TestProdu...
生产者消费者问题虚假唤醒
周莫客的博客
12-22 238
生产者消费者问题演示及解决 问题一： package com.mock; import org.junit.jupiter.api.Test; public class TestProducerAndConsumer { @Test public void test() { Product p = new Product(); new Threa...
生产者消费者问题之虚假唤醒
qq_38292204的博客
08-06 486
一、生产者消费者情景 在并发问题中，考虑这么一种生产者消费者情景： 设计A、B两个线程和一个参数count，如果count == 0，A线程进行生产，即对count + 1；如果count == 1，B线程进行消费，即对count - 1。 代码如下： public class ProducerConsumer { public static void main(String[] args) { Data data = new Data(); //A线程
23.生产者消费者案例-虚假唤醒
kfengqingyangk的博客
04-05 419
普通的生产者消费者案例 生产者线程：添加和创建数据的线程 消费者线程：删除和销毁数据的线程 public class TestProductAndConsumer { public static void main(String[] args) { Clerk clerk = new Clerk(); Productor productor = new Productor(cl
Java线程的虚假唤醒
风清云淡
07-12 293
虚假唤醒这个其实也算不上什么高深的点，简单来说就是**这个线程醒来时候干了不该干的事~**先来看个示例，然后再来分析下产生的原因。 小明放暑假了，每天的事情就是吃饭和睡觉，我们就把这个小明当做资源类。 ...
Java实现线程的生产者消费者问题解决方案
在计算机科学中，生产者与消费者问题是一个经典的多线程同步问题。它描述了共享缓冲区的生产者和消费者之间的协作关系。生产者向缓冲区中添加数据项，而消费者从中取出数据项进行处理。为了避免生产者在缓冲区满时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值