生产者消费者的五种实现

于 2020-04-02 16:43:17 发布
阅读量377 收藏
点赞数
分类专栏： Java
原文链接：https://www.jianshu.com/p/8123b85cdc87
版权

生产者消费者问题：
生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。

生产者消费者模式的优点:

  • 解耦
  • 支持并发
  • 支持忙闲不均

解决方法可分为两类：

  1. 用信号量和锁机制实现生产者和消费者之间的同步
  • wait() / notify()方法
  • await() / signal()方法
  • BlockingQueue阻塞队列方法
  • Semaphore方法
  1. 在生产者和消费者之间建立一个管道。（一般不使用，缓冲区不易控制、数据不易封装和传输）
  • PipedInputStream / PipedOutputStream

wait() / notify()方法

 

publicclassTest{
privatestaticIntegercount=0;
privatefinalIntegerFULL=5;
privatestaticStringlock="lock";

publicstaticvoidmain(String[]args){
Testt=newTest();
newThread(t.newProducer()).start();
newThread(t.newConsumer()).start();
newThread(t.newProducer()).start();
newThread(t.newConsumer()).start();
}

classProducerimplementsRunnable{
@Override
publicvoidrun(){
for(inti=0;i<5;i++){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
e1.printStackTrace();
}
synchronized(lock){
while(count==FULL){
try{
lock.wait();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
count++;
System.out.println("生产者"+Thread.currentThread().getName()
+"已生产完成，商品数量："+count);
lock.notifyAll();
}
}
}
}

classConsumerimplementsRunnable{
@Override
publicvoidrun(){
for(inti=0;i<5;i++){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
e1.printStackTrace();
}
synchronized(lock){
while(count==0){
try{
lock.wait();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
count--;
System.out.println("消费者"+Thread.currentThread().getName()
+"已消费，剩余商品数量："+count);
lock.notifyAll();
}
}
}
}
}

运行结果：

 

生产者Thread-0已生产完成，商品数量：1
生产者Thread-2已生产完成，商品数量：2
消费者Thread-1已消费，剩余商品数量：1
消费者Thread-3已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
消费者Thread-3已消费，剩余商品数量：0
生产者Thread-2已生产完成，商品数量：1
消费者Thread-1已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
生产者Thread-2已生产完成，商品数量：2
消费者Thread-1已消费，剩余商品数量：1
消费者Thread-3已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
消费者Thread-1已消费，剩余商品数量：0
生产者Thread-2已生产完成，商品数量：1
消费者Thread-3已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
消费者Thread-1已消费，剩余商品数量：0
生产者Thread-2已生产完成，商品数量：1
消费者Thread-3已消费，剩余商品数量：0

await() / signal()方法

await()/signal()是对wait()/notify()的改进，功能更加强大，更适用于高级用户，synchronized是托管给JVM执行的，而lock是Java写的控制锁的代码。

下面是使用ReentrantLock来实现生产者消费者问题:

 

publicclassTest{
privatestaticIntegercount=0;//缓冲区
privatefinalIntegerFULL=5;
finalLocklock=newReentrantLock();//获得可重入锁
finalConditionput=lock.newCondition();
finalConditionget=lock.newCondition();

publicstaticvoidmain(String[]args){

Testt=newTest();
newThread(t.newProducer()).start();
newThread(t.newConsumer()).start();
newThread(t.newConsumer()).start();
newThread(t.newProducer()).start();
}

//生产者
classProducerimplementsRunnable{
@Override
publicvoidrun(){
for(inti=0;i<5;i++){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
e1.printStackTrace();
}
//加锁
lock.lock();
try{
while(count==FULL){
try{
put.await();
}catch(InterruptedExceptione){
e.printStackTrace();
}
}
count++;
System.out.println("生产者"+Thread.currentThread().getName()
+"已生产完成，商品数量："+count);
//通知消费者，现在可以消费
get.signal();
}finally{
lock.unlock();
}
}
}
}

classConsumerimplementsRunnable{

@Override
publicvoidrun(){
for(inti=0;i<5;i++){
try{
Thread.sleep(1000);
}catch(InterruptedExceptione1){
e1.printStackTrace();
}
lock.lock();
try{
while(count==0){
try{
get.await();
}catch(Exceptione){
e.printStackTrace();
}
}
count--;
System.out.println("消费者"+Thread.currentThread().getName()
+"已消费，剩余商品数量："+count);
put.signal();
}finally{
lock.unlock();
}
}
}
}
}

运行结果：

 

生产者Thread-3已生产完成，商品数量：1
生产者Thread-0已生产完成，商品数量：2
消费者Thread-1已消费，剩余商品数量：1
消费者Thread-2已消费，剩余商品数量：0
生产者Thread-3已生产完成，商品数量：1
生产者Thread-0已生产完成，商品数量：2
消费者Thread-1已消费，剩余商品数量：1
消费者Thread-2已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
生产者Thread-3已生产完成，商品数量：2
消费者Thread-1已消费，剩余商品数量：1
消费者Thread-2已消费，剩余商品数量：0
生产者Thread-0已生产完成，商品数量：1
生产者Thread-3已生产完成，商品数量：2
消费者Thread-2已消费，剩余商品数量：1
消费者Thread-1已消费，剩余商品数量：0
生产者Thread-3已生产完成，商品数量：1
生产者Thread-0已生产完成，商品数量：2
消费者Thread-2已消费，剩余商品数量：1
消费者Thread-1已消费，剩余商品数量：0

BlockingQueue阻塞队列方法

BlockingQueue实现主要用于生产者-使用者队列，但它另外还支持Collection接口。是线程安全的，所有排队方法都可以使用内部锁或其他形式的并发控制来自动达到它们的目的。

用于阻塞的两个方法：

  • put()方法：将指定元素插入此队列中，将等待可用的空间（如果有必要）。
  • take()方法：获取并移除此队列的头部，在指定的等待时间前等待可用的元素（如果有必要）。

 

public class Test { 
    private static Integer count = 0; 
    final BlockingQueue<Integer> bq = new ArrayBlockingQueue<Integer>(5);// 容量为5的阻塞队列 
 
    public static void main(String[] args) { 
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
    } 
 
    class Producer implements Runnable { 
        @Override 
        public void run() { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    Thread.sleep(1000); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
                try { 
                    bq.put(1); 
                    count++; 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成，商品数量：" + count); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        } 
    } 
 
    class Consumer implements Runnable { 
 
        @Override 
        public void run() { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    Thread.sleep(1000); 
                } catch (InterruptedException e1) { 
                    e1.printStackTrace(); 
                } 
                try { 
                    bq.take(); 
                    count--; 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费，剩余商品数量：" + count); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
            } 
        } 
    } 
}

运行结果：

 

生产者Thread-0已生产完成，商品数量：0 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-3已生产完成，商品数量：0 
消费者Thread-2已消费，剩余商品数量：0 
生产者Thread-3已生产完成，商品数量：1 
消费者Thread-2已消费，剩余商品数量：1 
生产者Thread-0已生产完成，商品数量：2 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：2 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：1 
生产者Thread-0已生产完成，商品数量：1 
消费者Thread-1已消费，剩余商品数量：1 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：0 
消费者Thread-2已消费，剩余商品数量：0 
生产者Thread-3已生产完成，商品数量：1 
消费者Thread-1已消费，剩余商品数量：0

Semaphore方法实现同步

信号量（Semaphore）维护了一个许可集。在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个release()添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore只对可用许可的号码进行计数，并采取相应的行动。Semaphore通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

注意，调用acquire()时无法保持同步锁，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

 

public class Test { 
    int count = 0; 
    final Semaphore put = new Semaphore(5);// 初始令牌个数 
    final Semaphore get = new Semaphore(0); 
    final Semaphore mutex = new Semaphore(1); 
 
    public static void main(String[] args) { 
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Consumer()).start(); 
        new Thread(t.new Producer()).start(); 
    } 
 
    class Producer implements Runnable { 
        @Override 
        public void run() { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    Thread.sleep(1000); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } 
                try { 
                    put.acquire();// 注意顺序 
                    mutex.acquire(); 
                    count++; 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成，商品数量：" + count); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } finally { 
                    mutex.release(); 
                    get.release(); 
                } 
 
            } 
        } 
    } 
 
    class Consumer implements Runnable { 
 
        @Override 
        public void run() { 
            for (int i = 0; i < 5; i++) { 
                try { 
                    Thread.sleep(1000); 
                } catch (InterruptedException e1) { 
                    e1.printStackTrace(); 
                } 
                try { 
                    get.acquire();// 注意顺序 
                    mutex.acquire(); 
                    count--; 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费，剩余商品数量：" + count); 
                } catch (Exception e) { 
                    e.printStackTrace(); 
                } finally { 
                    mutex.release(); 
                    put.release(); 
                } 
            } 
        } 
    } 
}

运行结果：

 

生产者Thread-0已生产完成，商品数量：1 
消费者Thread-2已消费，剩余商品数量：0 
生产者Thread-3已生产完成，商品数量：1 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：1 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：1 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：1 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：1 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：1 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：1 
消费者Thread-1已消费，剩余商品数量：0 
生产者Thread-0已生产完成，商品数量：1 
生产者Thread-3已生产完成，商品数量：2 
消费者Thread-2已消费，剩余商品数量：1 
消费者Thread-1已消费，剩余商品数量：0

PipedInputStream / PipedOutputStream

这个类位于java.io包中，是解决同步问题的最简单的办法，一个线程将数据写入管道，另一个线程从管道读取数据，这样便构成了一种生产者/消费者的缓冲区编程模式。PipedInputStream/PipedOutputStream只能用于多线程模式，用于单线程下可能会引发死锁。

 

public class Test { 
    final PipedInputStream pis = new PipedInputStream(); 
    final PipedOutputStream pos = new PipedOutputStream(); 
 
    public static void main(String[] args) { 
        Test t = new Test(); 
        new Thread(t.new Producer()).start(); 
        new Thread(t.new Consumer()).start(); 
    } 
 
    class Producer implements Runnable { 
 
        @Override 
        public void run() { 
            try { 
                pis.connect(pos); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
            try { 
                while (true) { // 不断的产生数据 
                    int n = (int) (Math.random() * 255); 
                    System.out.println("生产者" + Thread.currentThread().getName() 
                            + "已生产完成，商品数量：" + n); 
                    pos.write(n); 
                    pos.flush(); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } finally { 
                try { 
                    pis.close(); 
                    pos.close(); 
                } catch (IOException e) { 
                    e.printStackTrace(); 
                } 
            } 
 
        } 
    } 
 
    class Consumer implements Runnable { 
 
        @Override 
        public void run() { 
            int n; 
            try { 
                while (true) { 
                    n = pis.read(); 
                    System.out.println("消费者" + Thread.currentThread().getName() 
                            + "已消费，剩余商品数量：" + n); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } finally { 
                try { 
                    pis.close(); 
                    pos.close(); 
                } catch (IOException e) { 
                    e.printStackTrace(); 
                } 
 
            } 
        } 
    } 
}

运行结果：

 

生产者Thread-0已生产完成，商品数量：6 
生产者Thread-0已生产完成，商品数量：158 
生产者Thread-0已生产完成，商品数量：79 
生产者Thread-0已生产完成，商品数量：119 
生产者Thread-0已生产完成，商品数量：93 
生产者Thread-0已生产完成，商品数量：213 
生产者Thread-0已生产完成，商品数量：151 
生产者Thread-0已生产完成，商品数量：101 
生产者Thread-0已生产完成，商品数量：125 
生产者Thread-0已生产完成，商品数量：109 
生产者Thread-0已生产完成，商品数量：67 
生产者Thread-0已生产完成，商品数量：109 
生产者Thread-0已生产完成，商品数量：132 
生产者Thread-0已生产完成，商品数量：139

 

ashui811
关注
专栏目录
生产者和消费者的三种实现方式（Java）
weixin_44730681的博客
02-15 1735
什么是生产者消费者问题 ? 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。 注：该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。 要解决该问题，就必须让生产者在缓冲区满时休眠（要
生产者消费者的一种实现方式
panda-star的博客
07-09 1015
一、要求 实现一个生产者、消费者场景。假设现在有一个任务调度系统负责处理数据，A线程负责从DB里拉待处理的任务放到队列；B线程组负责从队列中处理任务；由于任务处理量较大， 所以B线程会将任务进行拆分子线程并行处理。当所有子线程处理完成后，由B线程汇总结果并统一落库。 要求： 1、A线程组负责生产数据data； 2、B线程组负责消费data数据；A、B线程组要实现阻塞；请尽量考虑异常场景的
生产者与消费者的实现
qq_32445069的博客
03-23 226
生产者与消费者的实现 一到多个线程充当生产者，生产元素。一到多个线程充当消费者，消费元素。在两者之间插入一个队列充当缓冲区，建立起生产者和消费者的松散耦合。 正常情况下，即生产元素的速度和消费元素的速度差不多时，生产者和消费者其实是不需要去关注对方的。 生产者可以一直生产，因为队列里总是有空间。消费者可以一直消费，因为队列里总是有元素。即达到一个动态的平衡。 但在特殊情况下，比如生产元素的速度很...
生产者与消费者实现
今天也要好好学习哟
08-18 419
多线程中的生产者消费者问题实现
2、生产者-消费者模式的三种实现方式
weixin_30456039的博客
08-20 804
1、背景 生产者生产数据到缓冲区中，消费者从缓冲区中取数据。 如果缓冲区已经满了，则生产者线程阻塞； 如果缓冲区为空，那么消费者线程阻塞。 2、方式一：synchronized、wait和notify ...
实现生产者消费者的三种方式
热门推荐
ThinkWon的博客
10-14 1万+
文章目录wait/notify的消息通知机制预备知识wait/notify消息通知潜在的一些问题notify过早通知等待wait的条件发生变化假死状态wait/notifyAll实现生产者-消费者使用Lock中Condition的await/signalAll实现生产者-消费者使用BlockingQueue实现生产者-消费者 生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费...
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
Java实现简易生产者消费者模型过程解析
08-19
生产者消费者模型是一种常见的并发编程模型，在Java中可以通过使用同步机制和wait/notify机制来实现。在本文中，我们将通过一个简单的示例代码介绍Java实现简易生产者消费者模型的过程。 二、Java实现生产者消费者...
生产者-消费者问题的模拟实现（课设含源代码）.doc
03-03
通过这样的设计，可以实现生产者和消费者进程的并发执行，同时保证了资源的合理分配和避免了竞态条件的发生。这个模拟实现对于理解操作系统中的进程同步和互斥概念具有重要作用，也锻炼了编程和系统设计能力。
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 ...
python实现生产者消费者并发模型
11-22
多线程实现生产者消费者模型：锁（Lock）、信号量（Semaphore、BoundedSemaphore）、条件（Condition）、队列（Queue）、事件（Event） 多进程程实现生产者消费者模型：信号量（Semaphore）、条件（Condition）、...
java多线程实现生产者和消费者
04-15
java多线程实现生产者和消费者
生产者消费者模式实现
Array7的专栏
06-10 1083
生产者与消费者解耦，典型应用：MQ。不多解释，code talking： 调用模块： package com.array7.ds.pc; import java.util.concurrent.BlockingDeque; import java.util.concurrent.LinkedBlockingDeque; public class Run { public stat
生产者和消费者三种实现
liupeng_qwert的专栏
07-11 2297
1、syncronized+wait+notifypackage com.rrfare.producerconsumer;import java.util.LinkedList; import java.util.Queue; import java.util.Random;public class OrderManager { // 容器最大值 private static fina
实现生产者-消费者模式的五种方式
MOKE_SPACE
08-23 2387
在学习完 RabbitMQ 后，才明白为什么那么喜欢问生产者-消费者问题，因为在很多开发领域都能派上用场。 在 Java基础 以及 操作系统 都有接触，但还是要在这里再总结一下。 synchronized、wait()、notify() wait()：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让其他线程执行。 notify()：当生产者/消费者向缓冲区放...
生产者消费者的实现与思考
潜心种树
12-04 5403
生产者消费者的Java实现生产者：负责生产消息，在缓冲区满后休眠； 消费者：负责消费消息，在缓冲区空后休眠；两者的休眠何时唤醒？1.生产者休眠，是因为缓冲区满，所以只要消费者进行了消费，那么缓冲区就会有新的空间，生产者就可以继续生产，故每次消费者消费以后都要试图唤醒生产者，无论生产者是否休眠。2.消费者休眠，是因为缓冲区空，所以只要生产者进行了生成，那么缓冲区就会有新的消息，消费者就可以继续生产，
生产者消费者问题的java实现
longshengguoji的专栏
11-29 5115
生产者和消费者是多线程经典的问题，生产者和消费者问题的核心是同步的问题，同步问题的核心是要保证同一个资源被多个线程并发访问时的完整性，常用的方法是采用信号或加锁机制，保证资源在任一时刻只能被一个线程访问。这一问题用java来实现的话主要有4种方式。1.wait()/notify()；2.await()/signal(); 3.blockingQuene 4.PipedInputStream/pip
生产者消费者两种方式（管城法和信号灯表示法）
weixin_44007988的博客
09-09 164
并发协作模型一：生产者消费者模式实现方式一(管城法)，借助缓冲区 package cn.com.state; public class TestCooperation { //协作模型：生产者消费者实现方式一：管城法 //借助缓冲区 public static void main(String[] args) { // Container container...
Linux下生产者消费者模型的两种实现
"本文主要介绍了在Linux系统下如何实现生产者消费者模型，通过两种方法进行阐述，其中一种是结合信号量和互斥锁。" 在多线程编程中，生产者消费者模型是一种常见的同步和通信机制，用于解决线程间的协作问题。在该...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值