生产者/消费者

最新推荐文章于 2023-07-30 21:33:53 发布
最新推荐文章于 2023-07-30 21:33:53 发布
阅读量474 收藏
点赞数
分类专栏： 设计模式

1、生产者仅仅在仓储未满时候生产，仓满则停止生产。
2、消费者仅仅在仓储有产品时候才能消费，仓空则等待。
3、当消费者发现仓储没产品可消费时候会通知生产者生产。
4、生产者在生产出可消费产品时候，应该通知等待的消费者去消费。

解决生产者/消费者问题的方法可分为两类：
（1）采用某种机制保护生产者和消费者之间的同步；
（2）在生产者和消费者之间建立一个管道。

第一种方式有较高的效率，并且易于实现，代码的可控制性较好，属于常用的模式。
第二种管道缓冲区不易控制，被传输数据对象不易于封装等，实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。

同步问题核心在于：如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制，保证资源在任意时刻至多被一个线程访问。Java语言在多线程编程上实现了完全对象化，提供了对同步机制的良好支持。在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。
（1）wait() / notify()方法
（2）await() / signal()方法
（3）BlockingQueue阻塞队列方法
（4）PipedInputStream / PipedOutputStream
本文只介绍最常用的前三种，第四种暂不做讨论

1、wait() / notify()方法

wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。

wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

仓库类：

package cn.zhuang.lianxi.consume;

import java.util.LinkedList;

/**
 * 仓库类Storage实现缓冲区
 * @author zhuang
 */
public class Storage {
    private final int MAX_SIZE = 100;//仓库最大存储量
    private LinkedList<Object> list = new LinkedList<Object>();

    /*
     * 生产num个产品
     */
    public void produce(int num){
        //同步代码块
        synchronized (list) {
            //如果仓库剩余量不足
            while(list.size() + num > MAX_SIZE){
                System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"  
                        + list.size() + "/t暂时不能执行生产任务!");

                try {
                    list.wait();//由于条件不足，生产阻塞，放弃锁，让自己处于等待状态
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //当满足生产条件了，退出循环，生产num个产品
            for (int i = 0; i < num; i++) {
                list.add(new Object());
            }

            System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());

            list.notifyAll();//通知别的线程可以取了，同时自己放弃锁，处于等待状态
        }
    }

    /*
     * 消费num个产品
     */
    public void consume(int num){
        //同步代码段
        synchronized(list){
            //如果仓库不足num个产品
            while(list.size() < num){
                System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"  
                        + list.size() + "/t暂时不能执行生产任务!");
                try{
                    list.wait();//消费阻塞，一直循环等待，放弃锁，让自己处于等待状态
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            //消费满足条件，消费num个产品
            for (int i = 0; i < num; i++) {
                list.remove();
            }
            System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());

            list.notifyAll();//通知消费完毕，其他线程可以执行，放弃锁，让自己处于等待状态
        }
    }

    public LinkedList<Object> getList() {
        return list;
    }

    public void setList(LinkedList<Object> list) {
        this.list = list;
    }

    public int getMAX_SIZE() {
        return MAX_SIZE;
    }

}

生产者类：

package cn.zhuang.lianxi.consume;

public class Producer extends Thread{
    private int num; //每次生产数量
    private Storage storage;//放置的仓库

    public Producer(Storage storage){
        this.storage = storage;
    }

    public void produce(int num){
        storage.produce(num);
    }
    @Override
    public void run() {
        produce(num);//调用仓库的生产方法
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Storage getStorage() {
        return storage;
    }

    public void setStorage(Storage storage) {
        this.storage = storage;
    }
}

消费者类：

package cn.zhuang.lianxi.consume;

public class Consume extends Thread{
    private int num;// 每次消费的产品数量  
    private Storage storage; // 所在放置的仓库  

    public Consume(Storage storage){ // 构造函数，设置仓库  
        this.storage = storage;
    }

    public void consume(int num){
        storage.consume(num);// 调用仓库Storage的生产函数  
    }

    @Override
    public void run() { // 线程run函数  
        consume(num);
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    public Storage getStorage() {
        return storage;
    }

    public void setStorage(Storage storage) {
        this.storage = storage;
    }
}

测试类：

package cn.zhuang.lianxi.consume;

public class Test  
{  
    public static void main(String[] args)  
    {  
        // 仓库对象  
        Storage storage = new Storage();  

        // 生产者对象  
        Producer p1 = new Producer(storage);  
        Producer p2 = new Producer(storage);  
        Producer p3 = new Producer(storage);  
        Producer p4 = new Producer(storage);  
        Producer p5 = new Producer(storage);  
        Producer p6 = new Producer(storage);  
        Producer p7 = new Producer(storage);  

        // 消费者对象  
        Consumer c1 = new Consumer(storage);  
        Consumer c2 = new Consumer(storage);  
        Consumer c3 = new Consumer(storage);  

        // 设置生产者产品生产数量  
        p1.setNum(10);  
        p2.setNum(10);  
        p3.setNum(10);  
        p4.setNum(10);  
        p5.setNum(10);  
        p6.setNum(10);  
        p7.setNum(80);  

        // 设置消费者产品消费数量  
        c1.setNum(50);  
        c2.setNum(20);  
        c3.setNum(30);  

        // 线程开始执行  
        c1.start();  
        c2.start();  
        c3.start();  
        p1.start();  
        p2.start();  
        p3.start();  
        p4.start();  
        p5.start();  
        p6.start();  
        p7.start();  
    }  
}

结果图
这里写图片描述

二、await() / signal()方法

在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。

下面来看代码：
只需要更新仓库类Storage的代码即可，生产者Producer、消费者Consumer、测试类Test的代码均不需要进行任何更改。这样我们就知道为神马我要在Storage类中定义public void produce(int num);和public void consume(int num);方法，并在生产者类Producer和消费者类Consumer中调用Storage类中的实现了吧。将可能发生的变化集中到一个类中，不影响原有的构架设计，同时无需修改其他业务层代码。

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

/**
 * 仓库类Storage实现缓冲区
 */
public class Storage
{
    // 仓库最大存储量
    private final int MAX_SIZE = 100;

    // 仓库存储的载体
    private LinkedList<Object> list = new LinkedList<Object>();

    // 锁
    private final Lock lock = new ReentrantLock();

    // 仓库满的条件变量
    private final Condition full = lock.newCondition();

    // 仓库空的条件变量
    private final Condition empty = lock.newCondition();

    // 生产num个产品
    public void produce(int num)
    {
        // 获得锁
        lock.lock();

        // 如果仓库剩余容量不足
        while (list.size() + num > MAX_SIZE)
        {
            System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:" + list.size()
                    + "/t暂时不能执行生产任务!");
            try
            {
                // 由于条件不满足，生产阻塞
                full.await();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        // 生产条件满足情况下，生产num个产品
        for (int i = 1; i <= num; ++i)
        {
            list.add(new Object());
        }

        System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());

        // 唤醒其他所有线程
        full.signalAll();
        empty.signalAll();

        // 释放锁
        lock.unlock();
    }

    // 消费num个产品
    public void consume(int num)
    {
        // 获得锁
        lock.lock();

        // 如果仓库存储量不足
        while (list.size() < num)
        {
            System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:" + list.size()
                    + "/t暂时不能执行生产任务!");
            try
            {
                // 由于条件不满足，消费阻塞
                empty.await();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        // 消费条件满足情况下，消费num个产品
        for (int i = 1; i <= num; ++i)
        {
            list.remove();
        }

        System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());

        // 唤醒其他所有线程
        full.signalAll();
        empty.signalAll();

        // 释放锁
        lock.unlock();
    }

    // set/get方法
    public int getMAX_SIZE()
    {
        return MAX_SIZE;
    }

    public LinkedList<Object> getList()
    {
        return list;
    }

    public void setList(LinkedList<Object> list)
    {
        this.list = list;
    }
}
【要消费的产品数量】:50   【库存量】:0 暂时不能执行生产任务!
【要消费的产品数量】:30   【库存量】:0 暂时不能执行生产任务!
【已经生产产品数】:10    【现仓储量为】:10
【已经生产产品数】:10    【现仓储量为】:20
【要消费的产品数量】:50   【库存量】:20    暂时不能执行生产任务!
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!
【已经生产产品数】:10    【现仓储量为】:30
【要消费的产品数量】:50   【库存量】:30    暂时不能执行生产任务!
【已经消费产品数】:20    【现仓储量为】:10
【已经生产产品数】:10    【现仓储量为】:20
【要消费的产品数量】:30   【库存量】:20    暂时不能执行生产任务!
【已经生产产品数】:80    【现仓储量为】:100
【要生产的产品数量】:10   【库存量】:100   暂时不能执行生产任务!
【已经消费产品数】:50    【现仓储量为】:50
【已经生产产品数】:10    【现仓储量为】:60
【已经消费产品数】:30    【现仓储量为】:30
【已经生产产品数】:10    【现仓储量为】:40

三、BlockingQueue阻塞队列方法

BlockingQueue是JDK5.0的新增内容，它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await() / signal()方法。它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法。
put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。
take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。

import java.util.concurrent.LinkedBlockingQueue;

/**
 * 仓库类Storage实现缓冲区
 * 
 * Email:530025983@qq.com
 * 
 * @author MONKEY.D.MENG 2011-03-15
 * 
 */
public class Storage
{
    // 仓库最大存储量
    private final int MAX_SIZE = 100;

    // 仓库存储的载体
    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(
            100);

    // 生产num个产品
    public void produce(int num)
    {
        // 如果仓库剩余容量为0
        if (list.size() == MAX_SIZE)
        {
            System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");
        }

        // 生产条件满足情况下，生产num个产品
        for (int i = 1; i <= num; ++i)
        {
            try
            {
                // 放入产品，自动阻塞
                list.put(new Object());
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }

            System.out.println("【现仓储量为】:" + list.size());
        }
    }

    // 消费num个产品
    public void consume(int num)
    {
        // 如果仓库存储量不足
        if (list.size() == 0)
        {
            System.out.println("【库存量】:0/t暂时不能执行生产任务!");
        }

        // 消费条件满足情况下，消费num个产品
        for (int i = 1; i <= num; ++i)
        {
            try
            {
                // 消费产品，自动阻塞
                list.take();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }

        System.out.println("【现仓储量为】:" + list.size());
    }

    // set/get方法
    public LinkedBlockingQueue<Object> getList()
    {
        return list;
    }

    public void setList(LinkedBlockingQueue<Object> list)
    {
        this.list = list;
    }

    public int getMAX_SIZE()
    {
        return MAX_SIZE;
    }
}
【库存量】:0 暂时不能执行生产任务!
【库存量】:0 暂时不能执行生产任务!
【现仓储量为】:1
【现仓储量为】:1
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:8
【现仓储量为】:9
【现仓储量为】:10
【现仓储量为】:11
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:13
【现仓储量为】:14
【现仓储量为】:17
【现仓储量为】:19
【现仓储量为】:20
【现仓储量为】:21
【现仓储量为】:22
【现仓储量为】:23
【现仓储量为】:24
【现仓储量为】:25
【现仓储量为】:26
【现仓储量为】:12
【现仓储量为】:1
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:27
【现仓储量为】:8
【现仓储量为】:6
【现仓储量为】:18
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:8
【现仓储量为】:9
【现仓储量为】:10
【现仓储量为】:16
【现仓储量为】:11
【现仓储量为】:12
【现仓储量为】:13
【现仓储量为】:14
【现仓储量为】:15
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:3
【现仓储量为】:15
【现仓储量为】:1
【现仓储量为】:0
【现仓储量为】:1
【现仓储量为】:1
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:0
【现仓储量为】:1
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:8
【现仓储量为】:9
【现仓储量为】:10
【现仓储量为】:11
【现仓储量为】:12
【现仓储量为】:13
【现仓储量为】:14
【现仓储量为】:15
【现仓储量为】:16
【现仓储量为】:17
【现仓储量为】:1
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:3
【现仓储量为】:3
【现仓储量为】:1
【现仓储量为】:2
【现仓储量为】:3
【现仓储量为】:4
【现仓储量为】:5
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:8
【现仓储量为】:9
【现仓储量为】:10
【现仓储量为】:11
【现仓储量为】:12
【现仓储量为】:13
【现仓储量为】:14
【现仓储量为】:15
【现仓储量为】:16
【现仓储量为】:17
【现仓储量为】:18
【现仓储量为】:19
【现仓储量为】:6
【现仓储量为】:7
【现仓储量为】:8
【现仓储量为】:9
【现仓储量为】:10
【现仓储量为】:11
【现仓储量为】:12
【现仓储量为】:13
【现仓储量为】:14
【现仓储量为】:15
【现仓储量为】:16
【现仓储量为】:17
【现仓储量为】:18
【现仓储量为】:19
【现仓储量为】:20
【现仓储量为】:21
【现仓储量为】:22
【现仓储量为】:23
【现仓储量为】:24
【现仓储量为】:25
【现仓储量为】:26
【现仓储量为】:27
【现仓储量为】:28
【现仓储量为】:29
【现仓储量为】:30
【现仓储量为】:31
【现仓储量为】:32
【现仓储量为】:33
【现仓储量为】:34
【现仓储量为】:35
【现仓储量为】:36
【现仓储量为】:37
【现仓储量为】:38
【现仓储量为】:39
【现仓储量为】:40
壮少Bryant
关注
专栏目录
生产者消费者模型
snow_5288的博客
05-28 9140
一、概念引入日常生活中，每当我们缺少某些生活用品时，我们都会去超市进行购买，那么，你有没有想过，你是以什么身份去的超市呢？相信大部分人都会说自己是消费者，确实如此，那么既然我们是消费者，又是谁替我们生产各种各样的商品呢？当然是超市的各大供货商，自然而然地也就成了我们的生产者。如此一来，生产者有了，消费者也有了，那么将二者联系起来的超市又该作何理解呢？诚然，它本身是作为一座交易场所而诞生。将上述场景例
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
在IT领域，生产者/消费者问题是并发编程中的一个经典模型，用于展示同步和通信的概念。在Linux环境下，C语言可以通过多进程或多线程来实现这个模型。本篇将深入探讨如何利用这两种方法来模拟生产者/消费者问题，并...
生产者/消费者模式(转载)
w57w57w57的专栏
09-07 3430
★简介     在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。     单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而
经典消费者生产者问题
深夜的猫头鹰的博客
12-21 2万+
首先你需要了解多线程的流程以及实现多线程的几种方法，同时你要理解什么是并行、并发，以及线程和进程的区别，这里做简要的区别。 线程：一个进程包括多个线程 并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。 并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QP
并发设计模式之生产者-消费者模式
柳婼 の blog
11-25 2575
点击查看原文： http://www.joyhwong.com/2016/11/19/并发设计模式之生产者-消费者模式/ 生产者-消费者模式是一个经典的多线程设计模式，它为多线程间的协作提供了良好的解决方案。在生产者-消费者模式中，通常有两类线程，即若干个生产者和若干个消费者线程。生产者线程负责提交用户请求，消费者线程则负责处理生产者提交的任务。生产者和消费者之间通过共享内存缓冲区进行通信 如...
生产者/消费者模式的理解及实现
热门推荐
笑看风云路的博客
05-31 9万+
  ★简介   生产者消费者模式并不是GOF提出的23种设计模式之一，23种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是我们编程过程中最常用的一种设计模式。   在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模...
消息队列：生产者/消费者模式
qq_39575279的博客
02-28 2万+
1.什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。 这个阻塞队列就是用来给生产者和消费者解耦的。...
Java设计模式之生产者/消费者模式
红日
01-19 4401
一、什么是生产者/消费者模式？ 某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。在生产者与消费者之间在加个缓冲区，我们形象的称之为仓库，生产者负责往仓库了进商品，而消费者负责从仓库里拿商品，这就构成了生产者消费者模式。结构图如下： 二、生产者消费者模式的优点： 1、解耦: 由于有缓冲区的存在，生产者和消费者之间不直接依赖，耦合度降低。 2、支持并发: 由于生产者与消费者是两个独立的
操作系统实验 生产者/消费者模型
weixin_47826078的博客
05-06 4492
注：本文上半部分为原理，下半部分为实现 生产者 / 消费者模型： 生产者消费者模型具体来讲，就是在一个系统中，存在生产者和消费者两种角色，它们通过内存缓冲区进行通信。 概况描述： · 两个或者更多的进程（线程）共享同一个缓冲区； · 其中一个或多个进程（线程）作为“生产者”向缓冲区中添加数据； · 另一个或者多个进程（线程）作为“消费者”从缓冲区中取走数据； · 生产者和消费者必须互斥的使用缓冲区； · 缓冲区空时，消费者不能读取数据； · 缓冲区满时，生产者不能添加数据。 优点： （1） 解耦： · .
Java中的生产者/消费者模型
u010257931的博客
07-30 4949
生产者-消费者模型（Producer-Consumer problem）是一个非常经典的多线程并发协作的模型。比如某个模块负责生产数据，而另一个模块负责处理数据。产生数据的模块就形象地被称为生产者；而处理数据的模块，则被称为消费者。生产者和消费者在同一段时间内共用同一个存储空间，生产者往存储空间中添加产品，消费者从存储空间中取走产品，当存储空间为空时，消费者阻塞，当存储空间满时，生产者阻塞。
生产者/消费者模式之深入理解
3月3的风筝
11-01 1万+
★简介    在实际的软件开发过程中，经常会碰到如下场景：某个模块负责产生数据，这些数据由另一个模块来负责处理（此处的模块是广义的，可以是类、函数、线程、进程等）。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。     单单抽象出生产者和消费者，还够不上是生产者／消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 ...
生产者/消费者模式 阻塞队列 LinkedBlockingQueue
06-08
在生产者/消费者模式中，生产者通常通过`put()`方法将数据放入队列，而消费者则通过`take()`方法取出数据。这两个方法都具有阻塞特性，即当队列满时，`put()`会阻塞生产者线程；当队列空时，`take()`会阻塞消费者...
多线程模拟实现生产者／消费者模型
04-20
这个模型的核心思想是将生产者和消费者分隔开，使得生产者可以专注于创建产品，而消费者则专注于消耗这些产品，两者之间通过一个共享的数据缓冲区进行通信。 在Java等支持多线程的编程语言中，我们可以使用`Thread`...
操作系统实验：进程同步和死锁作业：编程模拟生产者/消费者问题（有界面 QT 可视化）
07-14
进程同步和死锁作业：编程模拟生产者/消费者问题 1、实验目的： 加深...2、实验说明：以生产者/消费者模型为根据，编写一个图形界面程序， 创建 n 个线程，使用 windows 信号量机制，模拟生产者和消费者的工作流程。
基于java学生宿舍管理系统设计与实现.docx
09-19
基于java学生宿舍管理系统设计与实现.docx
2023-04-06-项目笔记 - 第二百六十一阶段 - 4.4.2.259全局变量的作用域-259 -2025.09.19
最新发布
09-19
2023-04-06-项目笔记-第二百六十一阶段-课前小分享_小分享1.坚持提交gitee 小分享2.作业中提交代码 小分享3.写代码注意代码风格 4.3.1变量的使用 4.4变量的作用域与生命周期 4.4.1局部变量的作用域 4.4.2全局变量的作用域 4.4.2.1全局变量的作用域_1 4.4.2.259局变量的作用域_259- 2024-09-19
小程序-轻客洗衣.zip
09-19
小程序-轻客洗衣.zip
基于java的海鲜自助餐厅系统设计与实现.docx
09-19
基于java的海鲜自助餐厅系统设计与实现.docx
生产者/消费者模式详解：降低耦合与提高灵活性
"架构设计：生产者/消费者模式是一种广泛应用于软件开发中的经典设计模式，它旨在解决生产和消费数据时的协调问题。这个模式的核心思想是将数据生产者和数据消费者通过一个共享的缓冲区进行交互，从而降低它们之间的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值