Java 生产者消费者模式实现

已于 2022-05-02 18:35:16 修改
阅读量948 收藏
点赞数 1
分类专栏： 日常积累 Java学习 文章标签： java 开发语言 生产者消费者模式
于 2022-05-01 18:04:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MDJ_D2T/article/details/124529975
版权

文章目录

一、生产者消费者模式

题目：
有一个仓库，容量为N；有若干个生产者，将生产的产品存入到仓库中，除非仓库已满；又有若干消费者，从仓库中取出产品消费，除非仓库已空。请写一段程序，让这个模式正常运转，考虑到多线程并发情况。

二、代码实现

（一）synchronized + wait notifyAll 方式实现

1、代码

public class ProducerConsumerRun {
    public static void main(String[] args) {
        Resource resource = new Resource();
        ProducerThread p1 = new ProducerThread(resource);
        ProducerThread p2 = new ProducerThread(resource);
        ProducerThread p3 = new ProducerThread(resource);

        ConsumerThread c1 = new ConsumerThread(resource);

        p1.start();
        p2.start();
        p3.start();
        c1.start();
    }
}


public class Resource {
    private int num = 0; //资源计数
    private int size = 10; //资源池上限

    public synchronized void remove(){
        if(num>0){
            num--;
            System.out.println("消费者线程:"+Thread.currentThread().getName()+"消耗一个资源，当前资源剩余:"+num);
            notifyAll(); //唤醒所有等待线程
        }else{
            try {
                wait();
                System.out.println("消费者线程:"+Thread.currentThread().getName()+"当前无可消费资源，进入等待状态");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public synchronized void add(){
        if(num<size){
            num++;
            System.out.println("生产者线程:"+Thread.currentThread().getName()+"生产一个资源，当前资源剩余:"+num);
            notifyAll(); //唤醒所有等待线程
        }else{
            try {
                wait();
                System.out.println("生产者线程:"+Thread.currentThread().getName()+"当前不能生产资源，资源池已满，线程进入等待状态");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}



public class ProducerThread extends Thread {
    private Resource resource;
    public ProducerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep(1000); //一秒钟生产一个资源
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.add();
        }
    }
}


public class ConsumerThread extends Thread {
    private Resource resource;
    public ConsumerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep(1000); //一秒钟消耗一个资源
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.remove();
        }
    }
}

2、执行情况

从打印情况来看，当资源池满后，生产者线程进入等待时，消费者消费一个资源后，所有处于等待中的生产者都被唤醒了，将程序中的notifyAll 换成notify，会唤醒等待中的一个线程。

生产者线程:Thread-0生产一个资源，当前资源剩余:1
消费者线程:Thread-3消耗一个资源，当前资源剩余:0
生产者线程:Thread-1生产一个资源，当前资源剩余:1
生产者线程:Thread-2生产一个资源，当前资源剩余:2
生产者线程:Thread-0生产一个资源，当前资源剩余:3
消费者线程:Thread-3消耗一个资源，当前资源剩余:2
生产者线程:Thread-1生产一个资源，当前资源剩余:3
生产者线程:Thread-2生产一个资源，当前资源剩余:4
生产者线程:Thread-0生产一个资源，当前资源剩余:5
消费者线程:Thread-3消耗一个资源，当前资源剩余:4
生产者线程:Thread-1生产一个资源，当前资源剩余:5
生产者线程:Thread-2生产一个资源，当前资源剩余:6
生产者线程:Thread-0生产一个资源，当前资源剩余:7
消费者线程:Thread-3消耗一个资源，当前资源剩余:6
生产者线程:Thread-1生产一个资源，当前资源剩余:7
生产者线程:Thread-2生产一个资源，当前资源剩余:8
生产者线程:Thread-0生产一个资源，当前资源剩余:9
消费者线程:Thread-3消耗一个资源，当前资源剩余:8
生产者线程:Thread-1生产一个资源，当前资源剩余:9
生产者线程:Thread-2生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-0当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-0生产一个资源，当前资源剩余:10
生产者线程:Thread-2当前不能生产资源，资源池已满，线程进入等待状态
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-2当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-0当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-1当前不能生产资源，资源池已满，线程进入等待状态
消费者线程:Thread-3消耗一个资源，当前资源剩余:8
生产者线程:Thread-2生产一个资源，当前资源剩余:9
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-0当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-2生产一个资源，当前资源剩余:10

（二）Lock Condition + signalAll await方式实现

1、代码

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumerRun {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        Condition producerCondition = lock.newCondition();
        Condition consumerCondition = lock.newCondition();
        Resource resource = new Resource(lock,producerCondition,consumerCondition);
        ProducerThread p1 = new ProducerThread(resource);
        ProducerThread p2 = new ProducerThread(resource);
        ProducerThread p3 = new ProducerThread(resource);

        ConsumerThread c1 = new ConsumerThread(resource);

        p1.start();
        p2.start();
        p3.start();
        c1.start();
    }
}



import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;

public class Resource {
    private int num = 0;
    private int size = 10;
    private Lock lock;
    private Condition producerCondition;
    private Condition consumerCondition;

    public Resource(Lock lock, Condition producerCondition, Condition consumerCondition){
        this.lock = lock;
        this.producerCondition = producerCondition;
        this.consumerCondition = consumerCondition;
    }

    public void remove(){
        lock.lock();
        try {
            if (num > 0) {
                num--;
                System.out.println("消费者线程:" + Thread.currentThread().getName() + "消耗一个资源，当前资源剩余:" + num);
                producerCondition.signalAll();
            } else {
                try {
                    consumerCondition.await();
                    System.out.println("消费者线程:" + Thread.currentThread().getName() + "当前无可消费资源，进入等待状态");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }finally {
            lock.unlock();
        }
    }

    public void add(){
        lock.lock();
        try {
            if (num < size) {
                num++;
                System.out.println("生产者线程:" + Thread.currentThread().getName() + "生产一个资源，当前资源剩余:" + num);
                consumerCondition.signalAll();
            } else {
                try {
                    producerCondition.await();
                    System.out.println("生产者线程:" + Thread.currentThread().getName() + "当前不能生产资源，资源池已满，线程进入等待状态");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }finally {
            lock.unlock();
        }
    }
}


public class ProducerThread extends Thread {
    private Resource resource;
    public ProducerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep((long) (1000*Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.add();
        }
    }
}


public class ConsumerThread extends Thread {
    private Resource resource;
    public ConsumerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep((long) (1000*Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.remove();
        }
    }
}

2、执行情况

生产者线程:Thread-2生产一个资源，当前资源剩余:1
生产者线程:Thread-0生产一个资源，当前资源剩余:2
生产者线程:Thread-1生产一个资源，当前资源剩余:3
生产者线程:Thread-2生产一个资源，当前资源剩余:4
消费者线程:Thread-3消耗一个资源，当前资源剩余:3
生产者线程:Thread-2生产一个资源，当前资源剩余:4
生产者线程:Thread-2生产一个资源，当前资源剩余:5
生产者线程:Thread-0生产一个资源，当前资源剩余:6
消费者线程:Thread-3消耗一个资源，当前资源剩余:5
生产者线程:Thread-2生产一个资源，当前资源剩余:6
生产者线程:Thread-0生产一个资源，当前资源剩余:7
生产者线程:Thread-1生产一个资源，当前资源剩余:8
生产者线程:Thread-2生产一个资源，当前资源剩余:9
生产者线程:Thread-2生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-0当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-2当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-2当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-1当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-0生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-2当前不能生产资源，资源池已满，线程进入等待状态
生产者线程:Thread-0生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9`

（三）LinkedBlockingDeque 方式实现

1、代码


public class ProducerConsumerRun {
    public static void main(String[] args) {
        Resource resource = new Resource();
        ProducerThread p1 = new ProducerThread(resource);
        ProducerThread p2 = new ProducerThread(resource);
        ProducerThread p3 = new ProducerThread(resource);

        ConsumerThread c1 = new ConsumerThread(resource);

        p1.start();
        p2.start();
        p3.start();
        c1.start();
    }
}


import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

public class Resource {
    private BlockingQueue queue = new LinkedBlockingDeque(10);

    public void remove(){
        try {
            queue.take();
            System.out.println("消费者线程:" + Thread.currentThread().getName() + "消耗一个资源，当前资源剩余:" + queue.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void add(){
        try {
            queue.put(1);
            System.out.println("生产者线程:" + Thread.currentThread().getName() + "生产一个资源，当前资源剩余:" + queue.size());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}



public class ProducerThread extends Thread {
    private Resource resource;
    public ProducerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep((long) (1000*Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.add();
        }
    }
}


public class ConsumerThread extends Thread {
    private Resource resource;
    public ConsumerThread(Resource resource){
        this.resource = resource;
    }

    @Override
    public void run(){
        while(true){
            try {
                Thread.sleep((long) (1000*Math.random()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.remove();
        }
    }
}

2、执行情况

生产者线程:Thread-0生产一个资源，当前资源剩余:1
消费者线程:Thread-3消耗一个资源，当前资源剩余:0
生产者线程:Thread-1生产一个资源，当前资源剩余:1
消费者线程:Thread-3消耗一个资源，当前资源剩余:0
生产者线程:Thread-1生产一个资源，当前资源剩余:1
生产者线程:Thread-2生产一个资源，当前资源剩余:2
生产者线程:Thread-1生产一个资源，当前资源剩余:3
生产者线程:Thread-0生产一个资源，当前资源剩余:4
消费者线程:Thread-3消耗一个资源，当前资源剩余:3
生产者线程:Thread-1生产一个资源，当前资源剩余:4
生产者线程:Thread-2生产一个资源，当前资源剩余:5
生产者线程:Thread-1生产一个资源，当前资源剩余:6
生产者线程:Thread-1生产一个资源，当前资源剩余:7
消费者线程:Thread-3消耗一个资源，当前资源剩余:6
生产者线程:Thread-0生产一个资源，当前资源剩余:7
生产者线程:Thread-1生产一个资源，当前资源剩余:8
生产者线程:Thread-2生产一个资源，当前资源剩余:9
生产者线程:Thread-0生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-2生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-0生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-2生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-1生产一个资源，当前资源剩余:10
消费者线程:Thread-3消耗一个资源，当前资源剩余:9
生产者线程:Thread-0生产一个资源，当前资源剩余:10

参照文档：
生产者-消费者模式的三种实现方式：https://blog.csdn.net/datase/article/details/80070966

抓住小白白
关注
专栏目录
Java实现生产者-消费者模式
jsc723的专栏
12-14 490
Java实现生产者-消费者模式 1. 什么是生产者-消费者模式 生产者-消费者模式主要三种对象：生产者、消费者、队列。有一些生产者，每个生产者会生产一些产品，将它们放到队列中。这些产品会被消费者从队列中取出使用。队列存在最大长度，当队列满时，生产者需要等待消费者消费后才能继续将生产的产品放入队列中，当队列为空时，消费者需要等待生产者将新的产品放入队列才能继续消费产品。 2. 准备工作 我们可以把每个生产者和消费者看成一个线程，并且假设队列实现了如下的接口 队列接口 public interface IBlo
Java多线程生产者消费者模式实现过程解析
08-19
Java多线程生产者消费者模式实现过程解析 Java多线程生产者消费者模式是指在Java编程中，使用多线程来实现生产者和消费者之间的数据交换 и处理的模式。该模式下，生产者负责产生数据，而消费者负责处理数据。这种...
生产者消费者模式-Java实现
weixin_33796177的博客
03-03 503
感知阶段 　　　　随着软件业的发展，互联网用户的日渐增多，并发这门艺术的兴起似乎是那么合情合理。每日PV十多亿的淘宝，处理并发的手段可谓是业界一流。用户访问淘宝首页的平均等待时间只有区区几秒，但是服务器所处理的流程十分复杂。首先负责首页的服务器就有好几千台，通过计算把与用户路由最近的服务器处理首页的返回。其次是网页上的资源，就JS和CSS文件就有上百个，还有图片资源等。它能在几秒内加载出...
基于Java代码实现生产者和消费者
最新发布
2203_75607361的博客
08-08 438
基于Java代码实现生产者和消费者
Java实现生产者消费者模式
懒人闲得慌
08-19 283
介绍生产者消费者模式的四种不同实现 实现1：Object，wait，notifyAll 说明：生成String对象作为锁，通过boolean型变量hasValue来判断队列是否为空 （缺点：队列中仅包含一个对象） 注意：用notifyAll不用notify防止唤醒同类进程而锁住。 // 通过Object对象的wait,notifyAll实现 public class PC { pr...
Java实现生产者和消费者模式
热门推荐
扬帆向海的博客
10-26 1万+
从生产者、消费者模型会出现的问题出发，谈了一下对生产者、消费者模型的理解，并配有完整的代码实现。
Java生产者消费者模式
weixin_50518344的博客
08-21 384
在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题，所以便有了生产者和消费者模式。
Java生产者消费者模式实例分析
08-26
下面对Java生产者消费者模式的相关组成、原理及实现方法进行详细的分析和讲解。 一、生产者消费者模式的组成 Java生产者消费者模式由三个部分组成：生产者、消费者和缓存。生产者负责生产产品，消费者负责消费产品...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，BlockingQueue是Queue的子类，它提供了一个线程安全...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费...
Java多种方式实现生产者消费者模式
08-18
Java多种方式实现生产者消费者模式 Java中实现生产者消费者模式有多种方式，下面将详细介绍两种方式：使用synchronized和Object的wait和notifyAll方法，使用jdk1.8的Lock和Condition。 方式一：使用synchronized和...
Java 生产者消费者模式
10-22
自己空闲时间写的一个生产者和消费者模式。中间使用了中介者设计模式。大家可以参考下。
生产者/消费者模式 (java)
OUT of memory
03-31 809
生产者/消费者模式要求在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。 消费者线程从缓冲区中获得物品，然后释放缓冲区。 当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。 当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 优点： (1)解耦。假设生产
Java的生产者消费者模型
Andy-ZhangSir的博客
05-29 1535
前言 学完了线程后，我又去找了一些线程相关的练习题来练手，其中印象最深的就是生产者消费者模型这一块，为什么呢，因为它每一篇练习题里都有，开始没看懂，后面就去仔细研究了一下，哦，原来是这样，好像是懂了，那就来写写博客吧。哈哈哈…… 什么是生产者消费者模型 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲
Java中的生产者/消费者模型
u010257931的博客
07-30 4951
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
Java（二十二） -- 生产者消费者模式
bug 消灭师的博客
06-04 280
生产者消费者模式
用Java实现生产者消费者模式
climb_s的博客
10-10 256
采用synchronized锁以及wait notify方式实现 package com.stylefeng.guns.mq; import java.io.IOException; /** @author climb.s * @date 2018/9/27 19:14 */ public class WaitAndNotify { public static void main...
生产者消费者模式的Java实现
机械工程跑路哥
02-25 778
一.概述 1. 什么是“生产者消费者模式”？ 生产线程负责生产，消费线程负责消费 生产线程和消费线程要达到均衡。 生产满了就不能继续生产了，必须让消费线程进行消费 消费完了就不能再消费了，必须让生产线程进行生产 这是一种特殊的业务需求，在这种特殊的情况下，需要使用wait()和notify()方法 2.wait和notify方法 wait和notify方法不是线程当中的方法，是任何一个Java对象都有的方法（Object自带的，不是线程去调用） 3.wait()方法的作用？ ①让正在当前线程（o对象上活动
Java生产者消费者模式实现详解
"Java生产者消费者模式的多种实现方法，包括使用synchronized和Object的wait、notifyAll方法，以及使用BlockingQueue。" 在Java中，生产者消费者模式是一种多线程设计模式，用于解决线程间的数据共享和同步问题。...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值