消费者java_生产者消费者JAVA实现

最新推荐文章于 2024-07-10 09:44:18 发布
最新推荐文章于 2024-07-10 09:44:18 发布
阅读量72 收藏
点赞数
文章标签： 消费者java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42512021/article/details/114757534
版权

三种实现方式：

1. Object对象的wait(),notify()，加synchronize.

2. Lock的await(),signal().

3. BlockingQueue阻塞队列.

Object对象的wait(),notify()，加synchronize --> StorageObject();

Lock的await(),signal() --> StorageLock();

BlockingQueue阻塞队列 --> StorageBlockingQueue();

package concurent;

import java.util.LinkedList;

import java.util.concurrent.BlockingDeque;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* Created by jenkin K on 17/6/8.

*/

public class PCModelTread {

public static void main(String args[]){

// Storage storage = new StorageObject();

Storage storage = new StorageLock();

// Storage storage = new StorageBlockingQueue();

Producer p1 = new Producer(storage);

Producer p2 = new Producer(storage);

Producer p3 = new Producer(storage);

Producer p4 = new Producer(storage);

Consumer c1 = new Consumer(storage);

Consumer c2 = new Consumer(storage);

p1.setNum(6);

p2.setNum(1);

p3.setNum(1);

p4.setNum(8);

c1.setNum(1);

c2.setNum(5);

new Thread(p1, "producer1").start();

new Thread(p2, "producer2").start();

new Thread(p3, "producer3").start();

new Thread(p4, "producer4").start();

new Thread(c1, "consumer1").start();

new Thread(c2, "consumer2").start();

}

}

interface Storage {

public void consume(int num);

public void produce(int num);

}

class StorageObject implements Storage {

final int MAX_STORAGE = 10;

private LinkedList list = new LinkedList();

public void produce(int num){

synchronized (list){

while(num + list.size() > MAX_STORAGE){

System.out.println("库存:["+ list.size() + "]/["+ MAX_STORAGE +"], 待生产数量:[" + num + "], 生产阻塞:" + Thread.currentThread().getName() + "阻塞.");

try{

list.wait();

}catch (InterruptedException e){

e.printStackTrace();

}

}

for(int i = 0; i < num; i++){

list.add(new Object());

System.out.println("库存:["+ list.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在生产:[" + (i+1) + "].");

}

System.out.println(Thread.currentThread().getName() + "生产完成, 共生产:" + num + ", 库存:["+ list.size() + "]/["+ MAX_STORAGE +"].");

list.notifyAll();

}

}

public void consume(int num){

synchronized (list){

while(list.size() < num){

System.out.println("库存:["+ list.size() + "]/[" + MAX_STORAGE + "], 待消费数量:[" + num + "], 消费阻塞:" + Thread.currentThread().getName() + "阻塞.");

try{

list.wait();

}catch (InterruptedException e){

e.printStackTrace();

}

}

for(int i = 0; i < num; i++){

System.out.println("库存:["+ list.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在消费:[" + (i+1) + "].");

list.remove();

}

System.out.println(Thread.currentThread().getName() + "消费完成, 共消费:" + num + ", 库存:["+ list.size() + "]/["+ MAX_STORAGE + "].");

list.notifyAll();

}

}

}

class StorageLock implements Storage {

final int MAX_STORAGE = 10;

LinkedList list = new LinkedList();

Lock lock = new ReentrantLock(false);

Condition produce = lock.newCondition();

Condition consume = lock.newCondition();

@Override

public void produce(int num) {

lock.lock();

try {

while (num + list.size() > MAX_STORAGE) {

System.out.println("库存:[" + list.size() + "]/[" + MAX_STORAGE + "], 待生产数量:[" + num + "], 生产阻塞:" + Thread.currentThread().getName() + "阻塞.");

produce.await();

}

for (int i = 0; i < num; i++) {

list.add(new Object());

System.out.println("库存:[" + list.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在生产:[" + (i + 1) + "].");

}

System.out.println(Thread.currentThread().getName() + "生产完成, 共生产:" + num + ", 库存:[" + list.size() + "]/[" + MAX_STORAGE + "].");

}catch (InterruptedException e){

e.printStackTrace();

}finally {

produce.signalAll();

consume.signalAll();

lock.unlock();

}

}

@Override

public void consume(int num) {

lock.lock();

try {

while (list.size() < num) {

System.out.println("库存:[" + list.size() + "]/[" + MAX_STORAGE + "], 待消费数量:[" + num + "], 消费阻塞:" + Thread.currentThread().getName() + "阻塞.");

consume.await();

}

for (int i = 0; i < num; i++) {

System.out.println("库存:[" + list.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在消费:[" + (i + 1) + "].");

list.remove();

}

System.out.println(Thread.currentThread().getName() + "消费完成, 共消费:" + num + ", 库存:[" + list.size() + "]/[" + MAX_STORAGE + "].");

}catch (InterruptedException e){

e.printStackTrace();

}finally {

consume.signalAll();

produce.signalAll();

lock.unlock();

}

}

}

class StorageBlockingQueue implements Storage{

int MAX_STORAGE = 10;

BlockingQueue queue = new LinkedBlockingQueue(MAX_STORAGE);

@Override

public void produce(int num) {

if(queue.size() == MAX_STORAGE){

System.out.println("库存:[" + queue.size() + "]/[" + MAX_STORAGE + "], 待生产数量:[" + num + "], 生产阻塞:" + Thread.currentThread().getName() + "阻塞.");

}

for(int i = 0; i < num; i++){

try {

queue.put(new Object());

System.out.println("库存:[" + queue.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在生产:[" + (i + 1) + "].");

}catch (InterruptedException e){

e.printStackTrace();

}

}

System.out.println(Thread.currentThread().getName() + "生产完成, 共生产:" + num + ", 库存:[" + queue.size() + "]/[" + MAX_STORAGE + "].");

}

@Override

public void consume(int num) {

if(queue.size() == 0){

System.out.println("库存:[" + queue.size() + "]/[" + MAX_STORAGE + "], 待消费数量:[" + num + "], 消费阻塞:" + Thread.currentThread().getName() + "阻塞.");

}

for (int i = 1; i < num; i++){

try{

queue.take();

System.out.println("库存:[" + queue.size() + "]/[" + MAX_STORAGE + "], " + Thread.currentThread().getName() + "正在消费:[" + (i + 1) + "].");

}catch (InterruptedException e){

e.printStackTrace();

}

}

System.out.println(Thread.currentThread().getName() + "消费完成, 共消费:" + num + ", 库存:[" + queue.size() + "]/[" + MAX_STORAGE + "].");

}

}

class Producer implements Runnable {

Storage storage;

int num;

public Producer(Storage storage){

this.storage = storage;

}

@Override

public void run() {

produce(num);

}

public void produce(int num){

storage.produce(num);

}

public void setNum(int num) {

this.num = num;

}

}

class Consumer implements Runnable {

Storage storage;

int num;

public Consumer(Storage storage){

this.storage = storage;

}

@Override

public void run() {

consumer(num);

}

public void consumer(int num){

storage.consume(num);

}

public void setNum(int num) {

this.num = num;

}

}

输出结果：

StorageObject()输出结果：

库存:[1]/[10], producer1正在生产:[1].

库存:[2]/[10], producer1正在生产:[2].

库存:[3]/[10], producer1正在生产:[3].

库存:[4]/[10], producer1正在生产:[4].

库存:[5]/[10], producer1正在生产:[5].

库存:[6]/[10], producer1正在生产:[6].

producer1生产完成, 共生产:6, 库存:[6]/[10].

库存:[6]/[10], consumer2正在消费:[1].

库存:[5]/[10], consumer2正在消费:[2].

库存:[4]/[10], consumer2正在消费:[3].

库存:[3]/[10], consumer2正在消费:[4].

库存:[2]/[10], consumer2正在消费:[5].

consumer2消费完成, 共消费:5, 库存:[1]/[10].

库存:[1]/[10], consumer1正在消费:[1].

consumer1消费完成, 共消费:1, 库存:[0]/[10].

库存:[1]/[10], producer4正在生产:[1].

库存:[2]/[10], producer4正在生产:[2].

库存:[3]/[10], producer4正在生产:[3].

库存:[4]/[10], producer4正在生产:[4].

库存:[5]/[10], producer4正在生产:[5].

库存:[6]/[10], producer4正在生产:[6].

库存:[7]/[10], producer4正在生产:[7].

库存:[8]/[10], producer4正在生产:[8].

producer4生产完成, 共生产:8, 库存:[8]/[10].

库存:[9]/[10], producer3正在生产:[1].

producer3生产完成, 共生产:1, 库存:[9]/[10].

库存:[10]/[10], producer2正在生产:[1].

producer2生产完成, 共生产:1, 库存:[10]/[10].

StorageLock()输出结果：

库存:[1]/[10], producer1正在生产:[1].

库存:[2]/[10], producer1正在生产:[2].

库存:[3]/[10], producer1正在生产:[3].

库存:[4]/[10], producer1正在生产:[4].

库存:[5]/[10], producer1正在生产:[5].

库存:[6]/[10], producer1正在生产:[6].

producer1生产完成, 共生产:6, 库存:[6]/[10].

库存:[7]/[10], producer2正在生产:[1].

producer2生产完成, 共生产:1, 库存:[7]/[10].

库存:[8]/[10], producer3正在生产:[1].

producer3生产完成, 共生产:1, 库存:[8]/[10].

库存:[8]/[10], 待生产数量:[8], 生产阻塞:producer4阻塞.

库存:[8]/[10], consumer1正在消费:[1].

consumer1消费完成, 共消费:1, 库存:[7]/[10].

库存:[7]/[10], consumer2正在消费:[1].

库存:[6]/[10], consumer2正在消费:[2].

库存:[5]/[10], consumer2正在消费:[3].

库存:[4]/[10], consumer2正在消费:[4].

库存:[3]/[10], consumer2正在消费:[5].

consumer2消费完成, 共消费:5, 库存:[2]/[10].

库存:[3]/[10], producer4正在生产:[1].

库存:[4]/[10], producer4正在生产:[2].

库存:[5]/[10], producer4正在生产:[3].

库存:[6]/[10], producer4正在生产:[4].

库存:[7]/[10], producer4正在生产:[5].

库存:[8]/[10], producer4正在生产:[6].

库存:[9]/[10], producer4正在生产:[7].

库存:[10]/[10], producer4正在生产:[8].

producer4生产完成, 共生产:8, 库存:[10]/[10].

StorageBlockingQueue()输出结果：

库存:[3]/[10], producer2正在生产:[1].

库存:[3]/[10], consumer2正在消费:[2].

库存:[4]/[10], producer4正在生产:[1].

consumer1消费完成, 共消费:1, 库存:[4]/[10].

库存:[3]/[10], producer3正在生产:[1].

producer3生产完成, 共生产:1, 库存:[3]/[10].

库存:[2]/[10], producer1正在生产:[1].

库存:[3]/[10], producer4正在生产:[2].

库存:[2]/[10], consumer2正在消费:[3].

producer2生产完成, 共生产:1, 库存:[3]/[10].

库存:[4]/[10], consumer2正在消费:[4].

库存:[5]/[10], producer4正在生产:[3].

库存:[4]/[10], producer1正在生产:[2].

库存:[5]/[10], producer1正在生产:[3].

库存:[4]/[10], producer4正在生产:[4].

库存:[3]/[10], consumer2正在消费:[5].

库存:[7]/[10], producer4正在生产:[5].

库存:[6]/[10], producer1正在生产:[4].

库存:[8]/[10], producer4正在生产:[6].

consumer2消费完成, 共消费:5, 库存:[7]/[10].

库存:[10]/[10], producer4正在生产:[7].

库存:[9]/[10], producer1正在生产:[5].

从输出结果看，Synchronized和Lock方式，生产和消费是有序的，也就是某一生产线程全生产完，才会释放锁，不会被其他线程强占。BlockingQueue方式，生产和消费是无序的，即，生产线程没有生产完，或是消费线程没有消费完，都会被其他线程强占。原因是，前者的循环生产操作是在锁同步块里边，后者的生产循环生产操作是在锁的外面。

Ke Shao
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现简易生产者消费者模型过程解析
08-19
Java实现简易生产者消费者模型过程解析 一、概述 生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易...
java生产者消费者问题代码实现
12-25
Java 生产者消费者问题代码实现 Java 生产者消费者问题是计算机科学中的一种经典同步问题，它描述了多个生产者和消费者之间的关系，生产者负责生产数据，而消费者负责消费数据。在解决这个问题时，需要使用同步机制...
Java中的生产者/消费者模型
u010257931的博客
07-30 4560
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
Java实现生产者消费者问题
王梦杰_MengJie
04-26 4824
生产者-消费者问题是计算机科学中经典的同步问题之一，它描述了多个线程在共享数据的情况下如何协同工作。该问题通常涉及到一个共享缓冲区，其中生产者线程生成数据并将其放入缓冲区，而消费者线程从缓冲区中取出数据并对其进行处理。生产者和消费者线程必须协同工作，以避免竞态条件和死锁等问题。以上为通过Java代码实现解决生产消费者问题的实例，通过本实例希望大家能学会如果解决此问题，学会如何数据共享时，各个线程协同工作。
【转】-Java实现生产者和消费者的5种方式
最新发布
booleandev
07-10 945
生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。现在用四种方式来实现生产者消费者模型。
java-生产者消费者问题以及解决办法
Dawn的博客
07-27 4762
文章目录1.生产者消费者问题概述2.生产者消费者问题的解决办法2.1 解决思路2.2 实现方法2.3 代码实现2.3.1 wait()和nofity()方法2.3.2 await()/signal()方法2.3.3 BlockingQueue阻塞队列方法2.3.4 Semaphore信号量2.3.5 管道2.4.5.1 PipedInoutStream/PipedOutputStream（操作字节流）2.4.5.2 PipedReader/PipedWriter（操作字符流） 1.生产者消费者问题概述 生产
Java设计模式之生产者/消费者模式
红日
01-19 4333
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
Java 生产者和消费者3种实现方式
小博要变强啊~
01-24 750
Java 生产者和消费者3种实现方式。
Java实现Kafka生产者消费者代码实例
08-19
主要介绍了Java实现Kafka生产者消费者代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java实现生产者消费者
10-18
在Java中，`java.util.concurrent`包下的`BlockingQueue`接口提供了一种线程安全的数据结构，非常适合用于实现生产者消费者模式。生产者将产品放入队列，消费者从队列中取出产品。`BlockingQueue`提供了`put()`和`...
Java生产者和消费者例子_动力节点Java学院整理
08-30
在Java编程中，生产者-消费者问题是多线程并发控制的经典案例，主要涉及线程间的协作与同步。这个问题描述的是两个或多个线程共享一个有限的资源，如一个固定大小的缓冲区。在这个例子中，生产者线程负责生成数据并...
设计模式：生产者消费者模式
dghh81279的博客
08-30 554
在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式？ 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大...
三种方式实现Java生产者与消费者
木子陈的博客
03-10 6578
一、什么是生产者与消费者 生产者与消费者是java并发环境下常见的设计模式，一个线程负责生产数据，一个线程负责消费数据，两个线程同时去操作这个变量，但是这是两个相互互斥的操作。 二、代码演示 1、使用synchronized来实现，必须结合wait()与notify()方法来互斥，代码如下： /** * synchronized 版本生产者与消费者 */ public class SynchronizedConsumerAndProducer { /** * 队列长度
Java 生产者和消费者 5种实现方式
风信子
04-19 2819
Java 生产者和消费者 4种实现方式1 Objcet 的 wait() 和 notifyAll()2 1 Objcet 的 wait() 和 notifyAll() package com.xu.thread; import java.util.LinkedList; import java.util.List; import java.util.concurrent.atomic.AtomicInteger; /** * @author Administrator */ public class
Java并发编程学习(4):生产者消费者、线程状态转换
weixin_43968383的博客
05-27 89
生产者-消费者模型 要点 生产者仅负责产生数据结果，不关心数据如何处理 消费者专心处理数据结果 消息队列可以用来平衡生产者与消费者的线程资源 消息队列有容量限制，满时不会再加入数据 JDK中各种阻塞队列，采用的就是这种模式 代码示例 消息队列 消息队列是模型中核心组成部分，控制着入队和出队逻辑。 消息队列存在容量上线，当消息队列满时，如果有线程希望继续向队列中添加消息，则会进入等待状态；同理，当消息队列为空时，如果有线程希望继续从队列中取出消息，也会进入等待状态。 因此，再完成向消息队列中存入/取出消
一文理解java多线程之生产者消费者模型（三种实现）
qq_43800449的博客
04-12 2623
生产者和消费者之间通过一个缓冲区来进行交互，生产者负责生成数据，然后存入缓冲区；消费者则负责消费数据，从缓冲区获取。生产者和消费者只和缓冲区交互，没有直接联系。其中的同步互斥关系：生产者之间互斥，消费者之间也互斥生产者与消费者之间既又同步也有互斥（缓冲区满时，只能消费完再生产；缓冲区空时，只能生产完再消费）注意：缓存区要先进先出，所以一般用队列实现为什么要用生产者-消费者模型？
java:多线程解决生产者消费者问题
qq_55630615的博客
04-15 785
一个简单的多线程问题,当处理逻辑不完善时,容易出现所有线程都在等待的死锁情况.我在一开始写的时候,使用的是notify()方法,这会导致每次只唤醒一条线程,但如果之前出现了消费者或生产者的连续抢到cpu控制权情况,之前沉睡的线程就并不止有一条,最终导致全部等待的死锁情况.贴两张运行结果直观一点。
Java实现生产者消费者模型的三种方式
gbj2020的博客
12-11 1597
生产者-消费者模型是一种多线程并发模型，其中生产者线程负责生产数据，并将数据放入共享的缓冲区中，而消费者线程则负责从缓冲区中取出数据并进行处理。
Java 生产者-消费者模式的 3 种实现
weixin_41750142的博客
03-18 605
Java 生产者-消费者模式的 3 种实现
Java实现操作系统生产者-消费者问题
"操作系统课程设计，使用Java解决生产者-消费者问题，涉及多进程同步，有界缓冲区，线程同步及并发控制" 在操作系统中，生产者-消费者问题是多线程编程中的一个经典同步问题。这个问题模拟了生产者（产生资源）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值