生产者与消费者

已于 2022-02-18 15:55:31 修改
阅读量3.9k 收藏 7
点赞数 3
分类专栏： java 文章标签： java 开发语言
于 2022-02-18 15:54:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45794641/article/details/123005252
版权

生产者和消费者

目录

1.什么是生产者和消费者

​ 在日常生活中，我们去商店买东西，我们就是消费者，商店里面的某件商品有可能被卖完，那么这件商品就要生产(即进货)，要保持两者统一。不能说顾客去买东西，商店里面没有就没有了，当商店里面没有东西之后就要去生产(进货)，商店也是有限容量的，一件商品不能放太多，有个固定容量，生产的时候不能超过这个容量。

2.生产者和消费者(不加唤醒机制)
public class ProductorAndConsumer {
    public static void main(String[] args) {
        Market market = new Market();
        Productor productor = new Productor(market);
        Consumer consumer = new Consumer(market);
        
        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
    }
}

//商店
class Market{

    //某件商品数量，最开始为0
    private int product=0;

    //进货方法,在多线程环境下，如果不加锁会产生线程安全问题，这里加synchronized锁
    public synchronized void get(){
        //限定商店容量为10
        if(product>=10){
            System.out.println("仓库已满！");
        }else{
            System.out.println(Thread.currentThread().getName()+"进货成功！-->"+ ++product);
        }
    }

    //出售方法
    public synchronized void sale(){
        if(product<=0){
            System.out.println("已售罄！");
        }else {
            System.out.println(Thread.currentThread().getName()+"出售成功-->"+ --product);
        }
    }
}

//生产者,生产者不可能只有一个，所以是多线程的
class Productor implements Runnable{
    private Market market;

    public Productor(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买15个
        for (int i=0;i<15;i++){
            market.get();
        }
    }
}

//消费者
class Consumer implements Runnable{
    private Market market;

    public Consumer(){}

    public Consumer(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买10个
        for (int i=0;i<10;i++){
            market.sale();
        }
    }
}

​ 当不加唤醒机制的生产者和消费者模式，出现售罄情况时不会立即去生产，出现仓库已满情况时也不会立即去出售，如下：
在这里插入图片描述

3.生产者和消费者(加唤醒机制)
public class ProductorAndConsumer {
    public static void main(String[] args) {
        Market market = new Market();
        Productor productor = new Productor(market);
        Consumer consumer = new Consumer(market);

        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
    }
}

//商店
class Market{

    //某件商品数量，最开始为0
    private int product=0;

    //进货方法,在多线程环境下，如果不加锁会产生线程安全问题，这里加synchronized锁
    public synchronized void get(){
        //限定商店容量为10
        if(product>=10){
            System.out.println("仓库已满！");
            //当仓库已满，需要停止生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else{
            System.out.println(Thread.currentThread().getName()+"进货成功！-->"+ ++product);
            //当进货成功，就需要唤醒
            this.notifyAll();
        }
    }

    //出售方法
    public synchronized void sale(){
        if(product<=0){
            System.out.println("已售罄！");
            //售罄之后需要停止去生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+"出售成功-->"+ --product);
            //出售成功之后需要生产
            this.notifyAll();
        }
    }
}

//生产者,生产者不可能只有一个，所以是多线程的
class Productor implements Runnable{
    private Market market;

    public Productor(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买15个
        for (int i=0;i<15;i++){
            market.get();
        }
    }
}

//消费者
class Consumer implements Runnable{
    private Market market;

    public Consumer(){}

    public Consumer(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买10个
        for (int i=0;i<10;i++){
            market.sale();
        }
    }
}

​ 以上代码看起来没有什么问题，但是在实际运行时程序没有停止，如下图：
在这里插入图片描述

​ 分析问题原因，当生产者循环到最后一次时，消费者还有两次循环，当商品售罄之后，消费者会wait()，而生产者的循环已经结束，那么程序就一直会卡在wait()，不会结束。

4.解决虚假唤醒

​ 为了解决3出的问题，那么就要让消费者的最后一次循环中可以执行notifyAll()方法，这样才可以结束。

​ 那么就可以把else去掉，这样就可以使消费者最后一次执行结束，代码如下：

public class ProductorAndConsumer {
    public static void main(String[] args) {
        Market market = new Market();
        Productor productor = new Productor(market);
        Consumer consumer = new Consumer(market);

        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(productor,"生产者C").start();
        new Thread(consumer,"消费者D").start();
    }
}

//商店
class Market{

    //某件商品数量，最开始为0
    private int product=0;

    //进货方法,在多线程环境下，如果不加锁会产生线程安全问题，这里加synchronized锁
    public synchronized void get(){
        //限定商店容量为10
        while(product>10){
            System.out.println("仓库已满！");
            //当仓库已满，需要停止生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"进货成功！-->"+ ++product);
        //当进货成功，就需要唤醒
        this.notifyAll();
    }

    //出售方法
    public synchronized void sale(){
        while(product<=0){
            System.out.println("已售罄！");
            //售罄之后需要停止去生产
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(Thread.currentThread().getName()+"出售成功-->"+ --product);
        //出售成功之后需要生产
        this.notifyAll();
    }
}

//生产者,生产者不可能只有一个，所以是多线程的
class Productor implements Runnable{
    private Market market;

    public Productor(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买15个
        for (int i=0;i<15;i++){
            market.get();
        }
    }
}

//消费者
class Consumer implements Runnable{
    private Market market;

    public Consumer(){}

    public Consumer(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买10个
        for (int i=0;i<10;i++){
            market.sale();
        }
    }
}

​ 在修改以上代码中还出现了”虚假唤醒“的问题，即存在多个生产者和消费者的时候，当商店没有商品时，两个消费者都停在了wait()方法，然后生产者进行生产，生产一件之后，会执行notifyAll()方法，那么两个消费者都会去执行，就会出现商品不够的现象。

​ 为了解决以上问题，将if判断改成了while判断，生产者notifyAll()之后，消费者还需再次判断商品是否足够，不够继续wait()。

5.使用lock锁

​ 之前我们使用的是synchronized锁，我们现在改为lock同步锁进行替换。

【注意】：

  • 使用lock锁的时候，必须要对其进行释放，一般放在finally中
  • 使用lock锁之后，需要使用Condition进行唤醒操作
  • wait()方法变为await()方法
  • notify()变为singnal()方法
  • notifyAll()变为signalAll()方法
public class ProductorAndConsumer {
    public static void main(String[] args) {
        Market market = new Market();
        Productor productor = new Productor(market);
        Consumer consumer = new Consumer(market);

        new Thread(productor,"生产者A").start();
        new Thread(consumer,"消费者B").start();
        new Thread(productor,"生产者C").start();
        new Thread(consumer,"消费者D").start();
    }
}

//商店
class Market{

    //某件商品数量，最开始为0
    private int product=0;
    private Lock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    //进货方法,在多线程环境下，如果不加锁会产生线程安全问题，这里加synchronized锁
    public  void get(){
        lock.lock();
        try{
            //限定商店容量为10
            while(product>10){
                System.out.println("仓库已满！");
                //当仓库已满，需要停止生产
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"进货成功！-->"+ ++product);
            //当进货成功，就需要唤醒
            condition.signalAll();
        }finally {
            lock.unlock();
        }
    }

    //出售方法
    public synchronized void sale(){
        lock.lock();
        try{
            while(product<=0){
                System.out.println("已售罄！");
                //售罄之后需要停止去生产
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(Thread.currentThread().getName()+"出售成功-->"+ --product);
            //出售成功之后需要生产
            condition.signalAll();
        }finally {
            lock.unlock();
        }

    }
}

//生产者,生产者不可能只有一个，所以是多线程的
class Productor implements Runnable{
    private Market market;

    public Productor(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买15个
        for (int i=0;i<15;i++){
            market.get();
        }
    }
}

//消费者
class Consumer implements Runnable{
    private Market market;

    public Consumer(){}

    public Consumer(Market market){
        this.market=market;
    }

    @Override
    public void run() {
        //一次买10个
        for (int i=0;i<10;i++){
            market.sale();
        }
    }
}
6.面试题

​ 使用多线程实现先打印线程AA打印”AA“5次，线程BB打印”BB“10次，线程CC打印”CC“15次，总共打印10轮。

​ 【使用Lock中的Condition】

public class test {

    private static Integer a = 1;

    public static void main(String[] args) {
        /**
         * 线程的创建方式：
         *  1.new Thread
         *  2.Callable
         *  3.Runnable
         *  4.线程池
         */
        add add = new add();
        new Thread(()->{
           for (int i=0;i<10;i++){
               add.printAA(i);
           }
        },"AA").start();new Thread(()->{
           for (int i=0;i<10;i++){
               add.printBB(i);
           }
        },"BB").start();new Thread(()->{
           for (int i=0;i<10;i++){
               add.printCC(i);
           }
        },"CC").start();
    }
}


class add{

    private int flag=1;

    private Lock lock=new ReentrantLock();
    Condition condition1=lock.newCondition();
    Condition condition2=lock.newCondition();
    Condition condition3=lock.newCondition();


    //打印AA
    void printAA(int loop){
        lock.lock();
        try{
            while (flag!=1){
                try {
                    condition1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 0; i < 5; i++) {
                System.out.println("AA"+"轮数："+(loop+1));
            }
            flag++;
            condition2.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印BB
    void printBB(int loop){
        lock.lock();
        try{
            while (flag!=2){
                try {
                    condition2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 0; i < 10; i++) {
                System.out.println("BB"+"轮数："+(loop+1));
            }
            flag++;
            condition3.signal();
        }finally {
            lock.unlock();
        }
    }

    //打印CC
    void printCC(int loop){
        lock.lock();
        try{
            while (flag!=3){
                try {
                    condition3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            for (int i = 0; i < 15; i++) {
                System.out.println("CC"+"轮数："+(loop+1));
            }
            flag=1;
            condition1.signal();
        }finally {
            lock.unlock();
        }
    }

}

【使用Object中的wait、notify、notifyAll】

public class test {

    private static Integer a = 1;

    public static void main(String[] args) {
        /**
         * 线程的创建方式：
         *  1.new Thread
         *  2.Callable
         *  3.Runnable
         *  4.线程池
         */
        add add = new add();
        new Thread(()->{
           for (int i=0;i<10;i++){
               add.printAA(i);
           }
        },"AA").start();new Thread(()->{
           for (int i=0;i<10;i++){
               add.printBB(i);
           }
        },"BB").start();new Thread(()->{
           for (int i=0;i<10;i++){
               add.printCC(i);
           }
        },"CC").start();
    }
}


class add{

    private int flag=1;

    //打印AA
    synchronized void printAA(int loop){
        while (flag!=1){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag++;
        for (int i = 0; i < 5; i++) {
            System.out.println("AA"+"轮数："+(loop+1));
        }
        this.notifyAll();
    }

    //打印BB
    synchronized void printBB(int loop){
        while (flag!=2){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag++;
        System.out.println("BB"+"轮数："+(loop+1));
        this.notifyAll();
    }

    //打印CC
    synchronized void printCC(int loop){
        while (flag!=3){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        flag=1;
        System.out.println("CC"+"轮数："+(loop+1));
        this.notifyAll();
    }

}
java白中白.
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Labview生产者与消费者.vi
07-19
生产者与消费者之间传递的数据是一个连续的sine波形，二者靠大小为30个点的缓冲区连接。右下角是“停止”按钮，控制程序的停止执行。例程提供了操作方式控件控制生产者和消费者的数据传递速率，包含五种状态：不生产...
生产者消费者模式三种实现方式
热门推荐
weixin_38568503的博客
03-28 1万+
1.什么是生产者消费者模式： 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式，都会找一个第三者出来进行解耦，如工厂模式的第三者是工厂类，模板模式的第三者是模板类。在学习一些设计模式的过程中，如果先找到
采用信号量机制实现消费者与生产者的线程同步_经典生产者-消费者问题解析...
weixin_39603995的博客
12-05 993
1.生产者-消费者问题生产者和消费者问题在现实系统中是很普遍的。例如在一个多媒体系统中，生产者编码视频帧，而消费者消费（解码）视频帧，缓冲区的目的就是减少视频流的抖动。又如在图形用户接口设计中，生产者检测到鼠标和键盘事件，并将其插入到缓冲区中。消费者以某种基于优先级的方式从缓冲区中取出这些事件并显示在屏幕上。生产者和消费者模式共享一个有n个槽位的有限缓冲区。生产者反复地生成新的item，并将它插入...
操作系统之经典 | 生产者与消费者问题
chang466477509的博客
12-05 8771
文章目录一、生产者消费者问题概述二、生产者消费者模型优点三、生产者消费者模型变量定义四、生产者消费者流程图五、代码 一、生产者消费者问题概述 描述：俩个或者更多的线程共享同一个缓冲区，其中一个或多个线程作为“生产者”会不断地向缓冲区中添加数据，另一个或者多个线程作为“消费者”从缓冲区中取走数据。要注意以下几点： 生产者和消费者必须互斥的使用缓冲区 缓冲区空时，消费者不能读取数据 缓冲区满时，生产者不能添加数据 二、生产者消费者模型优点 1、解耦：因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，
生产者和消费者问题
XHHP
12-13 2307
生产者-消费者是一个经典的多线程协作问题。所谓生产者-消费者问题，实际上是包含两类线程，一种是生产者线程，用于生产数据，另一种是消费者线程，用于消费数据。为了解耦生产者和消费者的关系，通常会采用共享的数据区域。生产者往共享区域放数据，无需关心消费者的行为。消费者从共享区域取数据，无需关心生产者的行为。接下来，我们介绍几种方法来完成生产者-消费者模型。
生产者消费者模型
kalvin_y_liu的博客
10-24 5496
将上述场景例比到我们实际的软件开发过程中，经常会见到这样一幕：代码的某个模块负责生产数据（供货商），而生产出来的数据却不得不交给另一模块（消费者）来对其进行处理，在这之间我们必须要有一个类似上述超市的东西来存储数据（超市），这就抽象除了我们的生产者/消费者模型。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。
生产者与消费者.docx
12-28
通过c语言实现生产者与消费者问题
操作系统实验：生产者与消费者.cpp
05-12
通过实验模拟生产者与消费者之间的关系，了解并掌握他们之间的关系及其原理。由此增加对进程同步的问题的了解。 实验要求： 每个进程有一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程
pv.zip_生产者与消费者
09-20
使用多线程对生产者与消费者问题进行模拟；
Java生产者与消费者
11-28
Java生产者与消费者Demo
生产者-消费者模型
hao的博客
10-30 64
与此同时，消费者也从缓冲池中取出这些数据。在多线程开发中，如果生产者生产数据的速度很快，而消费者消耗数据的速度却很慢，那么生产者就必须等待消费者消耗数据后才能继续生产数据，因为存放数据的空间是有限的；同理如果消费者的速度大于生产者的速度，那么消费者就会经常处理等待状态，所以为了达到生产者和消费者生产数据和消费数据之间的平衡，就需要引入一个缓冲区来存储生产者生产的数据，所以就引入了生产者消费者模型。生产者-消费者模型一般用于将生产数据的一方和消费数据的一方分割开来，将生产数据与消费数据的过程解耦开来。
生产者消费者模式（c++实现）
dsjfhdwasfhgakjs的博客
10-22 856
c++实现生产者消费者模式
生产者消费者模式详细解析
weixin_53134102的博客
08-22 709
消费者生产者设计模式
（四）生产者消费者模式
roothahh的博客
04-08 9526
（一)生产者消费者模式原理： 在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。生产消费者模式如下图： （二）代码实现 生产者是一堆线程，消费者是另一堆线程，内存缓冲区可以使用List数组队列，数据类型只需要定义一个简单的类就好。最关键就是内存缓冲区为空的时候消费者必须等待，而内存缓冲区满的时候，生产者必须等待。其他时候可以是个动态平衡： 　 首先设置Market类： 其中变量有：Max（仓库最大值），List（用于存放数据） 方法有
生产者与消费者模式
无意呢的博客
07-09 729
所谓生产者与消费者模式就是通过平衡生产线程与消费线程的工作能力来提高程序整体处理数据的速度… 在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完才能继续生产数据，反之亦然，为了解决这种生产消费能力不均衡的问题，便有了生产者消费者模式。 下面先从一个简单的例子入手： package multithread;...
生产者/消费者模式(转载)
w57w57w57的专栏
09-07 3294
★简介     在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。     单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而
生产者-消费者模式
最新发布
BlueSakuraStar的博客
04-21 832
我们可以在生产者和消费者之间加一个阻塞队列（也可以是用阻塞队列实现的程序，或者是部署了阻塞队列的服务器），让生产者和消费者通过队列来进行通信，消费者把请求发送到队列里，消费者从队列中拿生产者发送的数据，生产者从队列中获取请求，把返回的响应发送到队列里。有的时候生产者生产数据的速度远远大于消费者取数据的速度，那么队列满的时候，生产者就进入阻塞状态，生产不了数据，等消费者取数据的时候才能从阻塞状态解除，继续去生产数据。在队列空的时候，出队列操作对进入阻塞，等队列不空的时候再解除阻塞，继续出队列。
生产者与消费者pv操作
10-28
生产者与消费者问题是指在一个共享的缓冲区中，生产者往缓冲区中添加数据，而消费者从缓冲区中取出数据。为了避免生产者和消费者同时访问缓冲区而导致数据不一致的问题，需要使用pv操作来实现同步。其中，p操作是指申请资源，v操作是指释放资源。在生产者与消费者问题中，可以使用互斥锁和条件变量来实现pv操作。具体来说，当生产者想要往缓冲区中添加数据时，需要先申请互斥锁，然后判断缓冲区是否已满，如果已满则等待条件变量，否则添加数据并释放互斥锁。当消费者想要从缓冲区中取出数据时，也需要先申请互斥锁，然后判断缓冲区是否为空，如果为空则等待条件变量，否则取出数据并释放互斥锁。这样可以保证生产者和消费者之间的同步，避免死锁的情况发生。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值