JAVA多线程（7）：生产者和消费者问题详解

最新推荐文章于 2023-04-08 14:18:37 发布
最新推荐文章于 2023-04-08 14:18:37 发布
阅读量597 收藏 5
点赞数
分类专栏： java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010886217/article/details/104941864
版权

一、生产者和消费者问题

二、问题产生和解决

1.不考虑线程同步导致的问题

2.解决进度25%：只是将Clerk中两个方法添加上了Sychronized

3.解决进度50%：添加线程通信，生产者生产满了等待；消费者消费完了，等待。

4.解决进度75%：生产者如果添加200ms的延迟，会导致，消费进程无法停止。

5.解决进度100%：多个生产者和消费者导致问题优化

一、生产者和消费者问题

针对同一个对象，消费者消费和生产者生产，是同时进行。这样会导致多线程访问问题，需要使用线程同步，解决这个问题。如下进行分步分析，从问题开始，到使用sychronized或者lock关键字，解决生产者和消费者问题。

二、问题产生和解决

1.不考虑线程同步导致的问题

（1）查看类图
 
（2）Clerk：共用类

package thread.thread.ProAndCon;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public void get(){
        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 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();
        }
    }
}

（3）生产者：Producer
实现功能：生产20个产品

package thread.thread.ProAndCon;

/**
 * 生产者
 */
class Producer implements Runnable{

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            clerk.get();
        }
    }
}

（4）消费者：Consumer
实现功能：消费20个产品

package thread.thread.ProAndCon;

/**
 * 消费者
 */
class Consumer implements Runnable{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            clerk.sale();
        }
    }
}


（5）测试类：TestProductorAndConsumer

package thread.thread.ProAndCon;

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

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


2.解决进度25%：只是将Clerk中两个方法添加上了Sychronized

（1）店员：Clerk

package thread.thread.ProAndCon_Sychronized;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        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();
        }
    }
}


（2）运行测试类会导致


/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

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

问题：生产者生产满了10个，但是持续生产；消费者消费到0个，继续消费。
 

生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
生产者A:10
产品已满！
产品已满！
产品已满！
产品已满！
产品已满！
产品已满！
产品已满！
消费者B:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
产品已没有了！
生产者A:1
生产者A:2
生产者A:3
生产者A:4


3.解决进度50%：添加线程通信，生产者生产满了等待；消费者消费完了，等待。

（1）店员：Clerk

package thread.thread.ProAndCon_Sychronized;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        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();
        }
    }
}

（2）运行测试类结果

生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
生产者A:10
产品已满！
消费者B:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0
产品已没有了！
生产者A:1
生产者A:2
生产者A:3
生产者A:4
生产者A:5
生产者A:6
生产者A:7
生产者A:8
生产者A:9
生产者A:10
消费者B:9
消费者B:8
消费者B:7
消费者B:6
消费者B:5
消费者B:4
消费者B:3
消费者B:2
消费者B:1
消费者B:0


4.解决进度75%：生产者如果添加200ms的延迟，会导致，消费进程无法停止。

（1）生产者添加200ms延迟（模拟生产环境）

package thread.thread.ProAndCon_Sychronized;

/**
 * 生产者
 */
class Producer implements Runnable{

    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i <= 20; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.get();
        }
    }
}

（2）店员：Clerk修改生产者上限为1

package thread.thread.ProAndCon_Sychronized;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        if(product>=1){
            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();
        }
    }
}

（3）运行测试代码：发现进程无法停止
 

（4）原因分析

情景：当消费者剩下1次，生产者剩下2次。
消费者消费最后一次，product=0，等待wait；
生产者生产倒数第2次，product=1，并且通知消费者，消费者完成最后一次进程，但是此时product=1；
生产者进行最后一次生产，product进入wait，而没有其他人唤醒，所以程序无法结束。
 

（5）解决问题：修改Clerk，把生产和消费的else去掉

package thread.thread.ProAndCon_SychronizedImp;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        if(product>=1){
            System.out.println("产品已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

//        else{
//            System.out.println(Thread.currentThread().getName()+":"+ ++product);
//            this.notifyAll();
//        }
        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();
//        }
        System.out.println(Thread.currentThread().getName()+":"+ --product);
        this.notifyAll();
    }
}

测试后结果：顺利结束

5.解决进度100%：多个生产者和消费者导致问题优化

（1）测试添加C生产者和D消费者

package thread.thread.ProAndCon_SychronizedImp_muti;

/**
 * Created by Administrator on 2020/1/16.
 */
public class TestProductorAndConsumer {

    public static void main(String[] args) {
        Clerk clerk=new Clerk();

        Producer producer=new Producer(clerk);
        Consumer consumer=new Consumer(clerk);

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

结果：

产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
消费者B:-1
产品已没有了！
消费者D:-2
产品已没有了！
消费者B:-3
产品已没有了！
消费者D:-4
产品已没有了！
消费者B:-5
产品已没有了！
消费者D:-6
产品已没有了！
消费者B:-7
产品已没有了！
消费者D:-8
产品已没有了！
消费者B:-9
产品已没有了！
消费者D:-10
产品已没有了！
消费者B:-11
产品已没有了！
生产者C:-10
消费者B:-11
产品已没有了！
消费者D:-12
产品已没有了！
消费者B:-13
产品已没有了！
消费者D:-14
产品已没有了！
消费者B:-15
产品已没有了！
消费者D:-16
产品已没有了！
消费者B:-17
产品已没有了！
消费者D:-18
产品已没有了！
消费者B:-19
产品已没有了！
消费者D:-20
产品已没有了！
消费者B:-21
产品已没有了！
消费者D:-22
产品已没有了！
消费者B:-23
产品已没有了！
消费者D:-24
产品已没有了！
消费者B:-25
产品已没有了！
消费者D:-26
产品已没有了！
消费者B:-27
产品已没有了！
消费者D:-28
产品已没有了！
消费者B:-29
产品已没有了！
消费者D:-30
产品已没有了！
消费者B:-31
产品已没有了！
消费者D:-32
产品已没有了！
消费者B:-33
产品已没有了！
消费者D:-34
产品已没有了！
消费者B:-35
产品已没有了！
消费者D:-36
产品已没有了！
消费者B:-37
产品已没有了！
消费者D:-38
产品已没有了！
消费者B:-39
消费者D:-40
生产者A:-39
生产者C:-38
生产者A:-37
生产者C:-36
生产者A:-35
生产者C:-34
生产者A:-33
生产者C:-32
生产者A:-31
生产者C:-30
生产者A:-29
生产者C:-28
生产者A:-27
生产者C:-26
生产者A:-25
生产者C:-24
生产者A:-23
生产者C:-22
生产者A:-21
生产者C:-20
生产者A:-19
生产者C:-18
生产者A:-17
生产者C:-16
生产者A:-15
生产者C:-14
生产者A:-13
生产者C:-12
生产者A:-11
生产者C:-10
生产者A:-9
生产者C:-8
生产者A:-7
生产者C:-6
生产者A:-5
生产者C:-4
生产者A:-3
生产者C:-2
生产者A:-1
生产者C:0
Process finished with exit code 0

（2）导致问题：虚假唤醒
（3）解决：修改Clerk类的生产和消费方法的if判断语句，为while循环判断

package thread.thread.ProAndCon_SychronizedImp_muti;

/**
 * 店员
 */
class Clerk{
    private int product=0;

    //进货
    public synchronized void get(){
        while(product>=1){
            System.out.println("产品已满！");
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

//        else{
//            System.out.println(Thread.currentThread().getName()+":"+ ++product);
//            this.notifyAll();
//        }
        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();
            }
        }
//        else {
//            System.out.println(Thread.currentThread().getName()+":"+ --product);
//            this.notifyAll();
//        }
        System.out.println(Thread.currentThread().getName()+":"+ --product);
        this.notifyAll();
    }
}

重新测试结果：

产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
产品已没有了！
生产者A:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者A:1
消费者D:0
产品已没有了！
产品已没有了！
生产者C:1
消费者B:0
产品已没有了！
产品已没有了！
生产者C:1
消费者D:0
产品已没有了！
生产者A:1
消费者B:0

 

RayBreslin
关注
专栏目录
多线程—生产者与消费者
weixin_44684207的博客
03-30 466
进程就相当于一条高速路，而线程就相当于这条高速上的多个车道。**线程结束，而进程不一定结束；进程结束，线程一定结束。** 日常中多线程访问全局变量通常会引起安全问题，为解决此安全问题，可以采用锁机制**threading.Lock()创建一个锁对象，用Lock.acquire()**进行枷锁操作，**Lock.release()**进行释放锁操作。 Notice：访问全局变量无需加锁，修改全局变量时才需要加锁，修改完毕之后释放锁。 以下以一个生产者线程和一个消费者线程为例。 相较于threading.L
生产者和消费者问题（java简单实现）
Super小龙的博客
05-10 671
生产者消费者问题（百度百科）：生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓
线程之生产者消费者
pomay的博客
07-19 288
/** * 生产者将产品交给店员，而消费者从店员处取走产品，店员一次只能取走固定数量的产品比如20，如果生产者试图生产更多产品， * 店员会叫生产者停一下，如果店中有空位放产品了，再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下， 如果店中有产品了，再通知消费者来拿 * * @author pomay * 分析： * 1.是否涉及到多线程问题？是 生产者、消费者
Java多线程-生产者和消费者
cmy_top的博客
06-23 81
生产者和消费者生产者消费者生产者和消费者代码实现 生产者 1.判断桌子上是否有披萨，有则等待，无则生产 2.把披萨放在桌子上 3.叫醒等待的消费者开吃 消费者 1.判断桌子上是否有披萨 2.如果没有则继续等待 3.如果有则开吃 4.吃完之后，桌子上的披萨就没有了，叫醒等待的生产者继续生产，披萨数量减1 生产者和消费者代码实现 生产者 package com.cmy.threaddemo10; /** * @author 陈明勇 */ public class Cooker extends
多线程（三）:生产者与消费者
weixin_46300935的博客
06-25 1445
3.1生产者和消费者模式概述【应用】 概述 生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。 所谓生产者消费者问题，实际上主要是包含了两类线程： 一类是生产者线程用于生产数据 一类是消费者线程用于消费数据 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者的实例详解 JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费...
Java多线程 BlockingQueue实现生产者消费者模型详解
08-25
Java多线程BlockingQueue实现生产者消费者模型详解 Java多线程中，生产者消费者模型是非常重要的一种设计模式，它可以解决多线程之间的数据传输问题。在Java中，我们可以使用BlockingQueue来实现生产者消费者模型，...
Java多线程 生产者消费者模型实例详解
08-25
Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下，生产者线程生产任务，消费者线程消费任务，而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解
08-29
Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解 该篇文章主要介绍了Java多线程之线程通信生产者消费者模式及等待唤醒机制代码详解，通过对生产者消费者模式的编程实现和等待唤醒机制的应用，阐述了多...
Java多线程：生产者消费者问题详解与解决方案
总结，解决Java多线程中的生产者与消费者问题，关键在于理解线程同步和通信机制，如何利用`wait()`和`notify()`来确保并发操作的正确性和顺序。在实际编程中，合理设计类结构，利用同步代码块或synchronized方法来...
Java多线程实现生产者消费者
05-29
编写一个“生产者-消费者”的多线程演示程序，两个生产者，一个消费者，可以存放产品的仓库容量为10，仓库用栈实现，并有同步功能，且能防止先消费后生产的情况。
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
12-30
Linux C语言 实现利用多进程或多线程模拟实现生产者/消费者问题。 （站在巨人的肩膀上）
多线程之生产者与消费者
清宵尚温的博客
05-01 924
多线程之生产者与消费者问题描述程序编写 问题描述 生产者消费者问题是一个非常典型性的线程交互的问题。 使用栈来存放数据 1.1 把栈改造为支持线程安全 1.2 把栈的边界操作进行处理，当栈里的数据是0的时候，访问pull的线程就会等待。 当栈里的数据是200的时候，访问push的线程就会等待 提供一个生产者（Producer）线程类，生产随机大写字符压入到堆栈 提供一个消费者（Consumer）...
多线程——生产者与消费者模式
niannujiao6的博客
08-01 420
在多线程的众多应用场景中，最为经典的线程通信是生产者与消费者模式了。此模式中生产者与消费者共享同一资源，并且互相依赖，互为条件。 应用场景 假设仓库只能存放一件商品，生产者将生产出来的商品放入仓库，消费者再从仓库中取走商品去消费。 如果仓库中已经存在商品，则生产者停止生产，直到消费者消费完商品， 如果仓库中无商品，则消费者停止消费，直到生产者生产出商品。 模式分析 对于生产者，没有生产商品之前，要通知消费者等待，生产商品之后，要通知消费者消费。 对于消费者，在消费商品之后，需要通知生产者生产新的商品以
Java代码解决生产者---消费者问题（两种方法）
热门推荐
阿顾的博客
09-11 1万+
本文通过两种方法解决生产者--消费者问题，思想都是通过锁的竞争进行资源的消耗或者生产，如果有疑问或者写的不好的地方可以留言沟通（代码中都作了详细的注释） 目录 方法一：synchronized, wait, notify  1.1 资源 1.2 消费者 1.3 生产者 1.4 测试代码 方法二：lock, condition, await, signal 2.1 资源 2.2 消...
【java多线程】生产者与消费者多线程同步案例
taojin12的博客
01-03 2321
文章目录生产者与消费者程序的基本实现解决数据同步线程等待与唤醒 生产者与消费者 在多线程的开发过程之中最为著名的案例就是生产者与消费者操作，该操作的主要流程如下： 生产者负责信息内容的生产； 每当生产者生产完成一项完整的信息之后消费者要从这里取走信息； 如果生产者没有完成生产则消费者要等待它完成生产，如果消费者还没有进行消费，则生产者应该等待消费处理完成后再继续生产。 程序的基本实现 可以将生...
进程管理 —— 生产者消费者问题
starter_____的博客
09-09 2259
一、问题描述 二、问题分析 三、实现 四、P、V操作的顺序 （1）所有的 P 操作都需要在 V 操作之前 以 producer 为例，调换 P(empty) 和 V(full) 的顺序，生产一个产品之后，由于 V(full) 无法阻塞进程，因此不管是否存在空闲缓冲区，就把产品放入缓冲区，这可能会导致缓冲区溢出，没有起到互斥的效果。 producer(){ while(1){ 生...
多线程经典问题：消费者与生产者问题Java代码（线程通信）
最新发布
qq_54414566的博客
04-08 195
1：假设仓库里只能存一件产品，生产者(Producer)将产品生产出来放入仓库，消费者(Consumer)将产品从仓库取出消费。2：管程法里生产者和消费者可以一次性生产或者消费多个产品；2：如果仓库里没有产品，生产者将产品放入仓库；如果有，停止生产并等待，直到仓库中的产品被消费者拿完为止。3：如果仓库里有产品，消费者可以取走消费；3：消费者需要去缓冲区(同步互斥)拿数据，生产需要向缓冲区放入数据，不能同时放入和拿取。1：管程法利用容器实现，信号灯法利用标志位实现。2：消费者负责处理数据(V)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值