Java之多线程的生产者消费者问题的详细解析

最新推荐文章于 2023-12-11 09:32:43 发布
最新推荐文章于 2023-12-11 09:32:43 发布
阅读量248 收藏
点赞数
分类专栏： java 文章标签： java 开发语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_69748833/article/details/133420648
版权

3.生产者消费者

3.1生产者和消费者模式概述【应用】

  • 概述

    生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。

    所谓生产者消费者问题，实际上主要是包含了两类线程：

    一类是生产者线程用于生产数据

    一类是消费者线程用于消费数据

    为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库

    生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为

    消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为

  • Object类的等待和唤醒方法

    方法名说明
    void wait()导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
    void notify()唤醒正在等待对象监视器的单个线程
    void notifyAll()唤醒正在等待对象监视器的所有线程

3.2生产者和消费者案例【应用】

  • 案例需求

    • 桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量

    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

      1.判断是否有包子,决定当前线程是否执行

      2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子

      3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子

    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

      1.判断是否有包子,决定当前线程是否执行

      2.如果没有包子,就进入等待状态,如果有包子,就消费包子

      3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子

    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

      创建生产者线程和消费者线程对象

      分别开启两个线程

  • 代码实现

    public class Desk {
​
    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;
​
    //汉堡包的总数量
    public static int count = 10;
​
    //锁对象
    public static final Object lock = new Object();
}
​
public class Cooker extends Thread {
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(!Desk.flag){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    }else{
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}
​
public class Foodie extends Thread {
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一
​
        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(Desk.flag){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
​
    }
}
​
public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/
​
        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/
​
        Foodie f = new Foodie();
        Cooker c = new Cooker();
​
        f.start();
        c.start();
​
    }
}

3.3生产者和消费者案例优化【应用】

  • 需求

    • 将Desk类中的变量,采用面向对象的方式封装起来

    • 生产者和消费者类中构造方法接收Desk类对象,之后在run方法中进行使用

    • 创建生产者和消费者线程对象,构造方法中传入Desk类对象

    • 开启两个线程

  • 代码实现

    public class Desk {
​
    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;
​
    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;
​
    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();
​
    public Desk() {
        this(false,10); // 在空参内部调用带参,对成员变量进行赋值,之后就可以直接使用成员变量了
    }
​
    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }
​
    public boolean isFlag() {
        return flag;
    }
​
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
​
    public int getCount() {
        return count;
    }
​
    public void setCount(int count) {
        this.count = count;
    }
​
    public Object getLock() {
        return lock;
    }
​
    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}
​
public class Cooker extends Thread {
​
    private Desk desk;
​
    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
​
    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}
​
public class Foodie extends Thread {
    private Desk desk;
​
    public Foodie(Desk desk) {
        this.desk = desk;
    }
​
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一
​
        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
​
    }
}
​
public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/
​
        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/
​
        Desk desk = new Desk();
​
        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);
​
        f.start();
        c.start();
​
    }
}

3.4阻塞队列基本使用【理解】

  • 阻塞队列继承结构

  • 常见BlockingQueue:

    ArrayBlockingQueue: 底层是数组,有界

    LinkedBlockingQueue: 底层是链表,无界.但不是真正的无界,最大为int的最大值

  • BlockingQueue的核心方法:

    put(anObject): 将参数放入队列,如果放不进去会阻塞

    take(): 取出第一个数据,取不到会阻塞

  • 代码示例

    public class Demo02 {
    public static void main(String[] args) throws Exception {
        // 创建阻塞队列的对象,容量为 1
        ArrayBlockingQueue<String> arrayBlockingQueue = new ArrayBlockingQueue<>(1);
​
        // 存储元素
        arrayBlockingQueue.put("汉堡包");
​
        // 取元素
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take()); // 取不到会阻塞
​
        System.out.println("程序结束了");
    }
}

3.5阻塞队列实现等待唤醒机制【理解】

  • 案例需求

    • 生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务

      1.构造方法中接收一个阻塞队列对象

      2.在run方法中循环向阻塞队列中添加包子

      3.打印添加结果

    • 消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务

      1.构造方法中接收一个阻塞队列对象

      2.在run方法中循环获取阻塞队列中的包子

      3.打印获取结果

    • 测试类(Demo)：里面有main方法，main方法中的代码步骤如下

      创建阻塞队列对象

      创建生产者线程和消费者线程对象,构造方法中传入阻塞队列对象

      分别开启两个线程

  • 代码实现

    public class Cooker extends Thread {
​
    private ArrayBlockingQueue<String> bd;
​
    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
​
    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
​
public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;
​
    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
​
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一
​
        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
​
    }
}
​
public class Demo {
    public static void main(String[] args) {
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);
​
        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);
​
        f.start();
        c.start();
    }
}

向着五星的方向
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JAVA多线程中的消费者生产者
maxker的博客
02-22 1129
面试题如何控制线程的执行顺序，生产者消费者问题
java多线程并发 ： 生产者-消费者模型的三种实现方式
火星男孩的分享空间
05-10 2830
生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 如果缓冲区已经满了，则生产者线程阻塞； 如果缓冲区为空，那么消费者线程阻塞。 方式一：synchronized、wait和notify package day4; //wait 和 notify public class ProducerConsumerWithWaitNofity { public static void main(String[] args) { Resource resource = new Resource
设计模式：生产者消费者模式
dghh81279的博客
08-30 547
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式？ 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大...
Java多线程08——生产者/消费者模式
QQ156881887的专栏
02-22 1058
多线程环境下，我们经常需要多个线程的并发和相互通信。其中，有一个重要的多线程并发协作模型，即“生产者/消费者模式”。生产者负责生产数据的模块，可以是方法、对象、线程或进程。消费者负责处理数据的模块，可以是方法、对象、线程或进程。缓冲区消费者不能直接使用生产者的数据，在生产者和消费者之间有一个“缓冲区”。生产者将生产好的数据和内容放入“缓冲区”，消费者从“缓冲区”中取走要处理的数据。实现线程的并发协作设置缓冲区后，生产者线程只需要向缓冲区里面放入数据，而不需要去查看消费者消费的情况；
Java多线程-工具篇-BlockingQueue(实现生产者和消费者模式)
li12412414的博客
01-17 5752
前言：      在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。 认识BlockingQueue 阻塞队列，顾名思义，首先它是一个队列，而一个队列
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
Java多线程并发生产者消费者设计模式实例解析
08-19
Java多线程并发生产者消费者设计模式实例解析 多线程并发生产者消费者设计模式是Java并发编程中的一种常见设计模式，旨在解决多个线程之间的同步问题。在这个设计模式中，生产者线程负责生产资源，而消费者线程负责...
Java多线程Queue、BlockingQueue和使用BlockingQueue实现生产消费者模型方法解析
08-28
Java多线程编程中，`Queue`和`BlockingQueue`是两种重要的数据结构，它们在并发处理和线程间通信中扮演着关键角色。`Queue`是一个先进先出（FIFO）的数据结构，用于存储和组织元素。它提供了一组基本操作，如`add()`...
java多线程_消费者与生产者模型
04-08
在Java多线程编程中，消费者-生产者模型是一种经典的线程间通信模式，用于解决多线程环境下的数据共享问题。该模型涉及到两个主要的角色：生产者（Producer）和消费者（Consumer）。生产者负责创建数据，而消费者则...
java模拟生产者和消费者问题
04-20
生产者-消费者问题是计算机科学中经典的多线程同步问题。它描述了两个线程（或进程）之间如何共享一个固定大小的缓冲区。其中，“生产者”负责生成数据并将其放入缓冲区，而“消费者”则负责从缓冲区中取出数据进行...
『JAVA多线程·学习之路』-生产者消费者问题（有代码实现）
Hhzzy99的博客
11-19 1992
java多线程学习-生产者和消费者问题的学习总结，包含了代码实现。
Java并发编程系列20:多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)
fen_fen的专栏
01-18 1614
Java多线程之生产者和消费者模式(使用Lock中Condition的await/signalAll)
Java实现生产者消费者模型的三种方式
最新发布
gbj2020的博客
12-11 1581
生产者-消费者模型是一种多线程并发模型，其中生产者线程负责生产数据，并将数据放入共享的缓冲区中，而消费者线程则负责从缓冲区中取出数据并进行处理。
Java中的多线程(生产者和消费者)
qq_58706693的博客
05-23 187
如果仓库中的商品没有满时，就可以唤醒生产者继续生产（消费端一旦消费就说明，仓库就有多余空间，这个时间点就可以使用notify() ）。这里我设置的仓库总容量为：10 ，根据两个线程的执行结果可以看出，两个线程是在相互争抢锁资源，而到达边界资源0的时候，消费者就会阻塞，消费者执行。生产者生产商品，消费者消费商品，商品就是它们的共享资源，因为商品是一个单个物品，所以我们引入一个仓库的概念，用来存放商品。对于消费者端：当仓库中有商品时我们就能消费，当仓库中的商品为0，那么消费者端的线程也就应该被阻断。
java多线程解决生产者与消费者问题
Mr_Richard的博客
07-08 304
java多线程解决生产者与消费者问题
生产者消费者模型（学习笔记）——java多线程典型案例
R_sir007的博客
08-06 649
生产者消费者模型是一种经典的并发编程模型，它描述的是一个共享资源池的问题。在这个模型中，生产者负责生产数据并将数据放入队列中，消费者线程则负责从队列中取出数据并消费。这个队列通常被设计成是线程安全的，以保证生产者和消费者能够同时操作它而不会出现数据错乱的问题。生产者消费者模型是一种非常重要的并发编程模型，它可以广泛应用于各种场景中，比如生产者线程生产数据，消费者线程处理数据，可以用于异步消息处理、多线程数据处理等。
java 多线程生产者与消费者
qq_42058998的博客
01-27 139
java多线程 生产者 消费者 以及虚假唤醒处理
Java 多线程案例之生产者-消费者模型以及阻塞队列的实现
weixin_63025863的博客
08-14 541
当队列满时，会阻塞执行入队列操作的线程，直到队列不为满，直至队列不满；当队列为空时，会阻塞执行出队列操作的线程，直至队列不为空。阻塞队列用在多线程的场景下，因此阻塞队列使用了锁机制来保证同步。生产者-消费者模型解决的是多线程或多进程之间数据共享和同步的问题，而阻塞队列作为一种数据结构，则为实现生产者-消费者模型提供了方便的工具。通过使用阻塞队列，可以减少开发人员处理并发问题的复杂性，同时提高代码的可维护性和可读性。
Java实现多线程中生产者、消费者问题，简单易懂
加贝要加倍努力的博客
02-01 5779
思想： 1、生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品 2、消费者在while循环里不停地消费产品，每消费一个，店员就移走一个产品 3、店员手里的产品少于20个，就从生产者那里拿走产品。等于20个，就停止从生产者那里拿走产品 4、店员手里的产品多于0个，就让消费者消费产品。等于0个，就停止让消费者消费产品 生产者： 生产者在while循环里不停地生产“产品”，每生产一个，就交给店员，店员就得到一个产品 //生产者 class Producte.
Java线程同步：生产者/消费者问题解析
这个概念在Java程序设计（进阶）中被详细阐述，特别是通过"生产者/消费者"问题来展示线程同步的必要性。 1. 线程同步的定义： 线程同步是指在多线程环境中，控制多个线程按照一定的顺序或者条件访问共享资源，避免...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

向着五星的方向

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

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

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

打赏作者

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

抵扣说明：

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

余额充值