Java 生产者和消费者模式详解

已于 2024-09-18 18:58:18 修改
阅读量386 收藏 5
点赞数 19
分类专栏： Java高级 文章标签： java 开发语言 学习
于 2024-09-18 18:57:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64178283/article/details/142340881
版权

1. 生产者和消费者模式概述

生产者和消费者模式是一种经典的并发设计模式，用于解决生产者和消费者之间数据共享问题。它主要涉及三个角色：

  • 生产者 (Producer)：负责生产数据，例如将数据写入文件、读取数据库数据等。

  • 消费者 (Consumer)：负责消费数据，例如将数据从文件中读取出来、对数据进行处理等。

  • 缓冲区 (Buffer)：用于存放生产者生产的数据，消费者可以从缓冲区中获取数据。

2. 生产者和消费者案例

案例描述：模拟一个仓库管理系统，生产者负责生产商品，消费者负责消费商品。

代码示例：

// 商品类
class Product {
    private String name;
    private int count;

    public Product(String name, int count) {
        this.name = name;
        this.count = count;
    }

    public String getName() {
        return name;
    }

    public int getCount() {
        return count;
    }
}

// 生产者
class Producer implements Runnable {
    private final List<Product> buffer; // 缓冲区
    private final int capacity; // 缓冲区容量

    public Producer(List<Product> buffer, int capacity) {
        this.buffer = buffer;
        this.capacity = capacity;
    }

    @Override
    public void run() {
        while (true) {
            // 生产商品
            Product product = new Product("商品", 10);
            // 等待缓冲区有空位
            synchronized (buffer) { // 使用同步块保证线程安全
                while (buffer.size() == capacity) {
                    try {
                        buffer.wait(); // 等待缓冲区有空位
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 生产商品入库
                buffer.add(product);
                System.out.println("生产者生产了商品：" + product.getName() + ", 库存数量：" + product.getCount());
                buffer.notifyAll(); // 唤醒所有等待的消费者线程
            }
            try {
                Thread.sleep(1000); // 模拟生产时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 消费者
class Consumer implements Runnable {
    private final List<Product> buffer; // 缓冲区

    public Consumer(List<Product> buffer) {
        this.buffer = buffer;
    }

    @Override
    public void run() {
        while (true) {
            // 等待缓冲区有商品
            synchronized (buffer) { // 使用同步块保证线程安全
                while (buffer.isEmpty()) {
                    try {
                        buffer.wait(); // 等待缓冲区有商品
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 消费商品
                Product product = buffer.remove(0);
                System.out.println("消费者消费了商品：" + product.getName() + ", 库存数量：" + product.getCount());
                buffer.notifyAll(); // 唤醒所有等待的生产者线程
            }
            try {
                Thread.sleep(1000); // 模拟消费时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class ProducerConsumer {
    public static void main(String[] args) {
        // 初始化缓冲区
        List<Product> buffer = new ArrayList<>();
        // 设置缓冲区容量
        int capacity = 5;
        // 创建生产者和消费者线程
        Producer producer = new Producer(buffer, capacity);
        Consumer consumer = new Consumer(buffer);
        // 启动线程
        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

解释：

  • synchronized 块: synchronized 块用于保证线程安全，确保同一时刻只有一个线程可以访问共享资源 buffer。

  • wait() 方法: 当生产者发现缓冲区已满，或消费者发现缓冲区为空时，它们会调用 wait() 方法进入等待状态。 进入等待状态的线程会释放锁，允许其他线程访问共享资源。

  • notifyAll() 方法: 当生产者生产完商品，或消费者消费完商品后，它们会调用 notifyAll() 方法唤醒所有在 buffer 上等待的线程。 唤醒后，等待线程会尝试再次获取锁，并继续执行。

3. 生产者和消费者案例优化

问题：上面的案例中，生产者和消费者都使用了 wait() 和 notifyAll() 方法进行同步，可能会导致虚假唤醒问题。 当线程被 notifyAll() 唤醒后，它并不能保证唤醒的原因是缓冲区状态发生了变化。

解决方案：使用条件变量来解决虚假唤醒问题。 条件变量允许线程等待特定条件的满足，避免了虚假唤醒问题。

代码示例：

// 生产者
class Producer {
    private final List<Product> buffer; // 缓冲区
    private final int capacity; // 缓冲区容量
    private final Condition notFull; // 缓冲区未满条件
    private final Condition notEmpty; // 缓冲区非空条件

    public Producer(List<Product> buffer, int capacity, Condition notFull, Condition notEmpty) {
        this.buffer = buffer;
        this.capacity = capacity;
        this.notFull = notFull;
        this.notEmpty = notEmpty;
    }

    public void produce() {
        // 生产商品
        Product product = new Product("商品", 10);
        // 等待缓冲区有空位
        synchronized (buffer) { // 使用同步块保证线程安全
            while (buffer.size() == capacity) {
                try {
                    notFull.await(); // 等待缓冲区有空位
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 生产商品入库
            buffer.add(product);
            System.out.println("生产者生产了商品：" + product.getName() + ", 库存数量：" + product.getCount());
            notEmpty.signalAll(); // 唤醒所有等待的消费者线程
        }
    }
}

// 消费者
class Consumer {
    private final List<Product> buffer; // 缓冲区
    private final Condition notFull; // 缓冲区未满条件
    private final Condition notEmpty; // 缓冲区非空条件

    public Consumer(List<Product> buffer, Condition notFull, Condition notEmpty) {
        this.buffer = buffer;
        this.notFull = notFull;
        this.notEmpty = notEmpty;
    }

    public void consume() {
        // 等待缓冲区有商品
        synchronized (buffer) { // 使用同步块保证线程安全
            while (buffer.isEmpty()) {
                try {
                    notEmpty.await(); // 等待缓冲区有商品
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 消费商品
            Product product = buffer.remove(0);
            System.out.println("消费者消费了商品：" + product.getName() + ", 库存数量：" + product.getCount());
            notFull.signalAll(); // 唤醒所有等待的生产者线程
        }
    }
}

public class ProducerConsumerOptimized {
    public static void main(String[] args) {
        // 初始化缓冲区
        List<Product> buffer = new ArrayList<>();
        // 设置缓冲区容量
        int capacity = 5;
        // 创建锁
        Lock lock = new ReentrantLock();
        // 创建条件变量
        Condition notFull = lock.newCondition();
        Condition notEmpty = lock.newCondition();
        // 创建生产者和消费者线程
        Producer producer = new Producer(buffer, capacity, notFull, notEmpty);
        Consumer consumer = new Consumer(buffer, notFull, notEmpty);
        // 启动线程
        new Thread(producer::produce).start();
        new Thread(consumer::consume).start();
    }
}

解释：

  • ReentrantLock 类: ReentrantLock 类提供了更灵活的锁机制，可以替代传统的 synchronized 块。

  • Condition 类: Condition 类用于创建条件变量，它与 ReentrantLock 关联。 每个条件变量对应一个特定的条件，线程可以通过 await() 方法等待该条件满足，并通过 signalAll() 方法唤醒所有等待该条件的线程。

4. 阻塞队列的基本使用

阻塞队列是一种线程安全的队列，它可以实现生产者和消费者之间的同步。 阻塞队列内部使用锁和条件变量来实现线程安全和等待唤醒机制。

代码示例：

import java.util.concurrent.ArrayBlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) {
        // 创建一个容量为 5 的阻塞队列
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
        // 生产者线程
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    // 将元素添加到队列
                    queue.put("元素 " + i); // 如果队列已满，则会阻塞直到有空间
                    System.out.println("生产者添加了元素：" + "元素 " + i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        // 消费者线程
        new Thread(() -> {
            while (true) {
                try {
                    // 从队列获取元素
                    String element = queue.take(); // 如果队列为空，则会阻塞直到有元素
                    System.out.println("消费者消费了元素：" + element);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

解释：

  • ArrayBlockingQueue 类: ArrayBlockingQueue 类是一个基于数组实现的阻塞队列，它提供了 put() 和 take() 方法来实现生产者和消费者之间的同步。

  • put() 方法: 如果队列已满，put() 方法会阻塞生产者线程，直到队列中有空位。

  • take() 方法: 如果队列为空，take() 方法会阻塞消费者线程，直到队列中有元素。

5. 阻塞队列实现等待唤醒机制

阻塞队列内部使用锁和条件变量来实现等待唤醒机制，保证线程之间的安全同步。

  • put() 方法: 当队列已满时，线程会调用 await() 方法，阻塞在条件变量上。当有元素被消费后，消费者会调用 signalAll() 方法，唤醒所有在条件变量上等待的生产者线程。

  • take() 方法: 当队列为空时，线程会调用 await() 方法，阻塞在条件变量上。当有元素被生产后，生产者会调用 signalAll() 方法，唤醒所有在条件变量上等待的消费者线程。

代码示例：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

// 生产者
class ProducerBlockingQueue {
    private final BlockingQueue<String> queue; // 阻塞队列

    public ProducerBlockingQueue(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void produce() {
        while (true) {
            try {
                // 生产商品
                String product = "商品";
                // 将元素添加到队列
                queue.put(product); // 如果队列已满，则会阻塞生产者线程
                System.out.println("生产者生产了商品：" + product);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 消费者
class ConsumerBlockingQueue {
    private final BlockingQueue<String> queue; // 阻塞队列

    public ConsumerBlockingQueue(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    public void consume() {
        while (true) {
            try {
                // 消费商品
                String product = queue.take(); // 如果队列为空，则会阻塞消费者线程
                System.out.println("消费者消费了商品：" + product);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class BlockingQueueWaitNotify {
    public static void main(String[] args) {
        // 创建一个阻塞队列
        BlockingQueue<String> queue = new LinkedBlockingQueue<>();
        // 创建生产者和消费者线程
        ProducerBlockingQueue producer = new ProducerBlockingQueue(queue);
        ConsumerBlockingQueue consumer = new ConsumerBlockingQueue(queue);
        // 启动线程
        new Thread(producer::produce).start();
        new Thread(consumer::consume).start();
    }
}

解释：

  • LinkedBlockingQueue 类: LinkedBlockingQueue 类是一个基于链表实现的阻塞队列，它提供了 put() 和 take() 方法来实现生产者和消费者之间的同步。

  • put() 方法: 如果队列已满，put() 方法会阻塞生产者线程，直到队列中有空位。

  • take() 方法: 如果队列为空，take() 方法会阻塞消费者线程，直到队列中有元素。

总结:

生产者和消费者模式是一种常用的并发设计模式，它可以有效地解决生产者和消费者之间的数据共享问题。 阻塞队列是实现生产者和消费者模式的便捷工具，它可以简化代码编写，提高代码可读性。 通过使用阻塞队列，我们可以避免使用复杂的同步机制，从而降低开发成本和维护成本。希望对各位看官有所帮助，感谢各位看官的观看，下期见，谢谢~

艾伦~耶格尔
关注
专栏目录
Java多线程：生产者消费者模型
流楚丶格念的博客
07-16 1985
一类是生产者线程用于生产数据一类是消费者线程用于消费数据为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为我们来看一个经典案例，可经典了，上课学，代码学，很多地方都会学到。...
Java实现生产者和消费者模式
悬在半空的博客
09-02 929
Java实现生产者和消费者模式案例。
Java基础进阶多线程-生产者和消费者模式
qq_46096136的博客
09-11 7745
1、什么是“生产者和消费者模式”？2、3、。。，，只是通知，
java中的生产者消费者模式详解
Gldwolf的博客
04-22 1141
方式 一： Synchronized方式 注：此种方式会造成资源的浪费： 利用锁的notifyAll()方法会将所有的线程都唤醒，会造成资源的浪费 class Resource { private String name; private int count = 1; private boolean flag = false; public synchronize...
java实现生产者消费者模式
向上的"狼"的博客
04-22 7894
一: 什么是生产者消费者模型 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 简单来说： 生产者消费者模型就是指，在一个系统中，存在两种角色，一个为生产者，一个为消费者，通过一个缓冲区（仓库）进行通信，生产者将生产的产品放入仓库，消费...
Java线程生产者消费者问题详解
qq_52972504的博客
08-10 1760
生产者消费者问题，也称有限缓冲问题，是一个多线程同步问题的经典案例。。生产者和消费者之间必须保持同步，要保证生产者不会在缓冲区满时放入数据，消费者也不会在缓冲区空时消耗数据。解决方法 采用某种机制保护生产者和消费者之间的同步。有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。在生产者和消费者之间建立一个管道。...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者模型是指使用JAVA编程语言和多线程技术来实现生产者消费者模型的实例详解。这种模型可以提高系统的并发性和性能，但需要合理地设计和实现线程安全和协作关系。 知识点： 1. 生产者消费...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解
08-29
该篇文章主要介绍了Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解，通过对生产者消费者模式的编程实现和等待唤醒机制的应用，阐述了多线程编程中的一些重要概念和技术。 一、生产者消费者模式 生产...
java并发学习之BlockingQueue实现生产者消费者详解
08-28
在生产者消费者模式中，BlockingQueue可以作为共享的队列，生产者不断地将元素放入队列中，而消费者则不断地从队列中取出元素。如果队列已满，生产者将被阻塞直到队列非满。如果队列为空，消费者将被阻塞直到队列...
Java-网络
2301_81543552的博客
09-14 717
Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。
自动生成不重复的订单id
ClaireCheney的博客
09-13 305
【代码】自动生成不重复的订单id。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1164
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
weixin_43860634的博客
09-14 755
Java项目: 基于SpringBoot+mybatis+maven课程答疑系统(含源码+数据库+毕业论文)
面试题篇: 跨域问题如何处理(Java和Nginx处理方式)
m0_66572126的博客
09-14 698
最常见的解决方案是在服务器端配置 CORS 头。服务器需要在响应中添加适当的 Access-Control-Allow-头来允许跨域请求。
Gradle
最新发布
xiaocaij_icai的博客
09-15 197
");
Java wrapperr打包springboot项目到linux和Windows
欢迎查阅
09-14 1020
测试启动就是点击App.bat 就会有信息的输出 installApp就是注册为一个windows上的一个服务。上图文件复制的地方 全部复制过去 保留自己需要的 然后去掉后缀.in。下载：linux的目前免费的 windows 64位的好像收费的。前提： 一定要有Java环境（我使用的是jdk1.8）解压的目录，然后我们新建自己的项目目录java-jsw。前面是你解压的原文件 后边是你自己建的目录路径。步骤和上面的一样 不过复制的文件不一样。下载一个社区版本的应该就够用了。需要注意的点 有Java环境。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 961
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 364
spirng security中的几大组件的差异和执行顺序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值