生产者消费者问题

已于 2022-05-03 17:03:44 修改
阅读量536 收藏 7
点赞数 6
分类专栏： Linux 文章标签： linux c语言 系统编程
于 2022-05-02 22:55:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61705102/article/details/124548152
版权

文章目录

问题概述

生产者消费者共享缓冲区，生产者向缓冲区中放数据，消费者从缓冲取中取数据，当缓冲区中被放满时，生产者线程就必须进入挂起状态，直到消费者从缓冲中取走数据时，生产者才能继续向缓冲区中存放数据，同样当缓冲取中没有数据时，消费者线程就必须进入挂起休眠状态，直到生产者向缓冲区中放入数据时，消费者才能被唤醒继续从缓冲区中取走数据。

单生产者单消费者队列

方法一（互斥锁和条件变量）

思路概述

使用队列的方式来存储产品，创建两个线程，一个生产者线程用来生产产品，生产的产品用头插的方法插进队列，另一个是消费者线程用来消费产品，使用互斥锁的方法让线程串行方式进行，消费者当产品为零时，也就是head->next==NULL，使用信号量函数pthread_cond_wait(&cond,&lock)让线程进入阻塞，直到有产品产出时，使用函数 pthread_cond_signal(&cond);唤醒被阻塞的线程。生产者，当产品到达最大容量时，做法与上类似，先让生产者线程进入阻塞，消费者线程将产品消耗后，该线程再次被唤醒

代码

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int i=0;//产品序号
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;//互斥量
#define MAX 8
void err_thread(int ret,const char*str)//检查错误
{
    if(ret!=0)
    {
        fprintf(stderr,"%s:%s\n",str,strerror(ret));
        exit(1);
    }
}
typedef struct SPSCQueue
{
    int ret;//产品内容
    struct SPSCQueue*next;
    int count;
}SPSCQueue;
SPSCQueue* head;//头节点
void*producer(void*arg)
{
    SPSCQueue*temp;
    while(1)
    {
        temp=(SPSCQueue*)malloc(sizeof(SPSCQueue));
        temp->ret=rand()%1000+1;
        head->count++;
        printf("产生一个产品%d:%d\n",++i,temp->ret);
        SPSCQueue*t;
        pthread_mutex_lock(&lock);//加锁
        if(head->count==MAX)//若果已到达最大容量，停止生产等待消费者消费
        {
            pthread_cond_wait(&cond,&lock);
        }
        t=head->next;
        head->next=temp;
        temp->next=t;
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond);
        sleep(rand()%2);
    }
    return NULL;
}
void*consumer(void*arg)
{
    SPSCQueue*temp;
    while(1)
    {
        pthread_mutex_lock(&lock);//加锁
        if(head->next==NULL)
        {
            pthread_cond_wait(&cond,&lock);//如果没有产品，等待生产者生产
        }
        temp=head;
        while(temp->next->next!=NULL)//找到尾节点的上一个
        {
            temp=temp->next;
        }
        printf("消费一个产品%d:%d\n",i--,temp->next->ret);
        head->count--;
        free(temp->next);
        temp->next=NULL;
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond);
        sleep(rand()%5);
    }
    return NULL;
}

int main()
{
    head=(SPSCQueue*)malloc(sizeof(SPSCQueue));
    head->next=NULL;
    head->count=0;
    pthread_t pid,cid;
    int ret;
    ret=pthread_create(&pid,NULL,producer,NULL);
    err_thread(ret,"create error");
    ret=pthread_create(&cid,NULL,consumer,NULL);
    err_thread(ret,"create error");
    ret=pthread_join(pid,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid,NULL);
    err_thread(ret,"join error");
    ret=pthread_mutex_destroy(&lock);
    err_thread(ret,"mutex destroy error");
    ret=pthread_cond_destroy(&cond);
    err_thread(ret,"cond destroy error");
    return 0;
}

方法二（信号量）

思路概述

创建两个信号量，product_num和blank_num，
product_num表示现在所拥有的产品的数量，初始化为0.
blank_num表示现在剩余容量，初始化为8.
生产者生产产品时，product_num++,blank_num- -;如果blank_num已经等于零则该线程进入阻塞等待,等待被唤醒。
消费者消费产品时，product_num- -,blank_num++;如果product_num已经等于零则该线程进入阻塞等待，等待被唤醒。

代码

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
#include<semaphore.h>
int i=0;//产品序号
sem_t product_num,blank_num;
#define MAX 8
void err_thread(int ret,const char*str)//检查错误
{
    if(ret!=0)
    {
        fprintf(stderr,"%s:%s\n",str,strerror(ret));
        exit(1);
    }
}
typedef struct SPSCQueue
{
    int ret;//产品内容
    struct SPSCQueue*next;
    int count;
}SPSCQueue;
SPSCQueue* head;//头节点
void*producer(void*arg)
{
    SPSCQueue*temp;
    while(1)
    {
        sem_wait(&blank_num);
        temp=(SPSCQueue*)malloc(sizeof(SPSCQueue));
        temp->ret=rand()%1000+1;
        head->count++;
        printf("产生一个产品%d:%d\n",++i,temp->ret);
        SPSCQueue*t;
        t=head->next;
        head->next=temp;
        temp->next=t;
        sem_post(&product_num);
        sleep(rand()%2);
    }
    return NULL;
}
void*consumer(void*arg)
{
    SPSCQueue*temp;
    while(1)
    {
        sem_wait(&product_num);
        temp=head;
        while(temp->next->next!=NULL)//找到尾节点的上一个
        {
            temp=temp->next;
        }
        printf("消费一个产品%d:%d\n",i--,temp->next->ret);
        head->count--;
        free(temp->next);
        temp->next=NULL;
        sem_post(&blank_num);
        sleep(rand()%5);
    }
    return NULL;
}

int main()
{
    sem_init(&product_num,0,0);
    sem_init(&blank_num,0,8);
    head=(SPSCQueue*)malloc(sizeof(SPSCQueue));
    head->next=NULL;
    head->count=0;
    pthread_t pid,cid;
    int ret;
    ret=pthread_create(&pid,NULL,producer,NULL);
    err_thread(ret,"create error");
    ret=pthread_create(&cid,NULL,consumer,NULL);
    err_thread(ret,"create error");
    ret=pthread_join(pid,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid,NULL);
    return 0;
}

多生产者多消费者队列(这里以3个生产者3个消费者为例)

方法一

思路概述

与单生产者单消费者队列类似，但次数会出现多个生产者和多个消费者，所以在判断产品数量为零消费者无法和产品数量达到上线生产者无法生产，要用循环去多次判断。

  while(head->count==MAX)//若果已到达最大容量，停止生产等待消费者消费
  {
    pthread_cond_wait(&cond,&lock);
  }

   while(head->next==NULL)
   {
     pthread_cond_wait(&cond,&lock);//如果没有产品，等待生产者生产
   }

代码

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
int i=0;//产品序号
pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;//互斥锁
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;//互斥量
#define MAX 8//最大容量
void err_thread(int ret,const char*str)//检查错误
{
    if(ret!=0)
    {
        fprintf(stderr,"%s:%s\n",str,strerror(ret));
        exit(1);
    }
}
typedef struct MPMCQueue
{
    int ret;//产品内容
    struct MPMCQueue*next;
    int count;
}MPMCQueue;
MPMCQueue* head;//头节点
void*producer(void*arg)
{
    MPMCQueue*temp;
    while(1)
    {
        temp=(MPMCQueue*)malloc(sizeof(MPMCQueue));
        temp->ret=rand()%1000+1;
        pthread_mutex_lock(&lock);//加锁
        while(head->count==MAX)//若果已到达最大容量，停止生产等待消费者消费
        {
            pthread_cond_wait(&cond,&lock);
        }
        head->count++;
        printf("产生一个产品%d:%d\n",++i,temp->ret);
        MPMCQueue*t;
        t=head->next;
        head->next=temp;
        temp->next=t;
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond);
        sleep(rand()%2);
    }
    return NULL;
}
void*consumer(void*arg)
{
    MPMCQueue*temp;
    while(1)
    {
        pthread_mutex_lock(&lock);//加锁
        while(head->next==NULL)
        {
            pthread_cond_wait(&cond,&lock);//如果没有产品，等待生产者生产
        }
        temp=head;
        while(temp->next->next!=NULL)//找到尾节点的上一个
        {
            temp=temp->next;
        }
        printf("消费一个产品%d:%d\n",i--,temp->next->ret);
        head->count--;
        free(temp->next);
        temp->next=NULL;
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&cond);
        sleep(rand()%2);
    }
    return NULL;
}

int main()
{
    head=(MPMCQueue*)malloc(sizeof(MPMCQueue));
    head->next=NULL;
    head->count=0;
    pthread_t pid1,pid2,pid3,cid1,cid2,cid3;
    int ret;
    ret=pthread_create(&pid1,NULL,producer,NULL);//生产者1
    err_thread(ret,"create error");
    ret=pthread_create(&pid2,NULL,producer,NULL);//生产者2
    err_thread(ret,"create error");
    ret=pthread_create(&pid3,NULL,producer,NULL);//生产者3
    err_thread(ret,"create error");
    ret=pthread_create(&cid1,NULL,consumer,NULL);//消费者1
      err_thread(ret,"create error");
    ret=pthread_create(&cid2,NULL,consumer,NULL);//消费者2
      err_thread(ret,"create error");
    ret=pthread_create(&cid3,NULL,consumer,NULL);//消费者3
    err_thread(ret,"create error");
    ret=pthread_join(pid1,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(pid2,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(pid3,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid1,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid2,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid3,NULL);
    err_thread(ret,"join error");
    ret=pthread_mutex_destroy(&lock);
    err_thread(ret,"mutex destroy error");
    ret=pthread_cond_destroy(&cond);
    err_thread(ret,"cond destroy error");
    return 0;
}

方法二（信号量）

思路概述

和单生产者单消费者的思路类似，就不再过多赘述

代码

#include<stdio.h>
#include<unistd.h>
#include<pthread.h>
#include<string.h>
#include<stdlib.h>
#include<errno.h>
#include<semaphore.h>
int i=0;//产品序号
sem_t product_num;
sem_t blank_num;
#define MAX 8//最大容量
void err_thread(int ret,const char*str)//检查错误
{
    if(ret!=0)
    {
        fprintf(stderr,"%s:%s\n",str,strerror(ret));
        exit(1);
    }
}
typedef struct MPMCQueue
{
    int ret;//产品内容
    struct MPMCQueue*next;
    int count;
}MPMCQueue;
MPMCQueue* head;//头节点
void*producer(void*arg)
{
    MPMCQueue*temp;
    while(1)
    {
        temp=(MPMCQueue*)malloc(sizeof(MPMCQueue));
        temp->ret=rand()%1000+1;
        sem_wait(&blank_num);
        head->count++;
        printf("产生一个产品%d:%d\n",++i,temp->ret);
        MPMCQueue*t;
        t=head->next;
        head->next=temp;
        temp->next=t;
        sem_post(&product_num);
        sleep(rand()%2);
    }
    return NULL;
}
void*consumer(void*arg)
{
    MPMCQueue*temp;
    while(1)
    {
        sem_wait(&product_num);
        temp=head;
        while(temp->next->next!=NULL)//找到尾节点的上一个
        {
            temp=temp->next;
        }
        printf("消费一个产品%d:%d\n",i--,temp->next->ret);
        head->count--;
        free(temp->next);
        temp->next=NULL;
        sem_post(&blank_num);
        sleep(rand()%2);
    }
    return NULL;
}

int main()
{
    sem_init(&product_num,0,0);//刚开始产品数量为0
    sem_init(&blank_num,0,8);//刚开始空格为8
    head=(MPMCQueue*)malloc(sizeof(MPMCQueue));
    head->next=NULL;
    head->count=0;
    pthread_t pid1,pid2,pid3,cid1,cid2,cid3;
    int ret;
    ret=pthread_create(&pid1,NULL,producer,NULL);//生产者1
    err_thread(ret,"create error");
    ret=pthread_create(&pid2,NULL,producer,NULL);//生产者2
    err_thread(ret,"create error");
    ret=pthread_create(&pid3,NULL,producer,NULL);//生产者3
    err_thread(ret,"create error");
    ret=pthread_create(&cid1,NULL,consumer,NULL);//消费者1
      err_thread(ret,"create error");
    ret=pthread_create(&cid2,NULL,consumer,NULL);//消费者2
      err_thread(ret,"create error");
    ret=pthread_create(&cid3,NULL,consumer,NULL);//消费者3
    err_thread(ret,"create error");
    ret=pthread_join(pid1,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(pid2,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(pid3,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid1,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid2,NULL);
    err_thread(ret,"join error");
    ret=pthread_join(cid3,NULL);
    err_thread(ret,"join error");
    return 0;
}
binary~
关注
  • 6
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
认识生产者消费者问题
Cecilia3333的博客
04-11 301
生产者消费者问题是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”，在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者在缓冲区中消耗这些数据。该问题的关键是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区空时消耗数据。要解决这个问题，就必须让生产者在缓冲区满时休眠，等到下次消费...
华南理工大学操作系统实验：生产者消费者问题
12-15
参考教材中的生产者消费者算法，创建5个进程，其中两个进程为生产者进程，3个进程为消费者进程。一个生产者进程试图不断地在一个缓冲中写入大写字母，另一个生产者进程试图不断地在缓冲中写入小写字母。3个消费者不断地从缓冲中读取一个字符并输出。为了使得程序的输出易于看到结果，仿照的实例程序，分别在生产者和消费者进程的合适的位置加入一些随机睡眠时间。 可选的实验：在上面实验的基础上实现部分消费者有选择地消费某些产品。例如一个消费者只消费小写字符，一个消费者只消费大写字母，而另一个消费者则无选择地消费任何产品。消费者要消费的产品没有时，消费者进程被阻塞。注意缓冲的管理。
经典同步问题一——生产者和消费者问题
yilia学习小园
04-16 575
不懂得结构型信号量的小伙伴可参考下面博文，之后再阅读本博文，更易于理解 https://blog.csdn.net/weixin_36465540/article/details/105559848 生产者和消费者问题 问题描述 一个或多个生产者产生数据并放在缓冲区中，每次一个。 一个或多个消费者从缓冲区取数据项并消费，每次一个。 条件： 1 在任意时间只能一个生产者或消费者访问缓冲区——互斥 2...
一生产者多消费者模型 / 多生产者一消费者模型
weixin_43808717的博客
04-01 684
1. 异常问题（wait问题） wait中断：在调用处立即中断并且释放锁，该线程转入等待队列。当收到持有同一把锁的线程notify通知后进入锁池队列，再次获得同步锁之后才会继续执行。这里的继续执行是从上次中断处继续向下执行。 package 多线程核心.生产者与消费者问题.一生产多消费操作栈假死与异常; import java.util.ArrayList; class MyService{ private ArrayList list = new ArrayList(); synchr
操作系统实验二·生产者消费者问题
zhj12399的博客
12-05 9044
生产者消费者问题1实验目的2实验内容3实验环境3.1Windows3.2Linux虚拟机4程序设计和实现4.1Windows实现4.1.1函数解释4.1.2程序代码4.1.3运行结果4.2Linux实现4.2.1函数解释4.2.2程序代码4.2.3运行结果 Make C or C++ programs to illustrate the Producer and Consumer synchronization problem. You will have to create several process
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
Linux线程编程之生产者消费者问题
12-14
　本文基于顺序循环队列，给出Linux生产者/消费者问题的多线程示例，并讨论编程时需要注意的事项。文中涉及的代码运行环境如下： 　本文假定读者已具备线程同步的基础知识。 　一 顺序表循环队列 　1.1 ...
Java实现生产者消费者问题
12-22
　生产者消费者图 　存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。 　JAVA解决线程模型的三种方式 　1...
一文搞懂 生产者-消费者问题
qq_34211771的博客
01-13 1785
PV原语 在操作系统的课程中，我们有学习到PV原语，所谓原语，即为不可中断的过程。我们可以先简单的理解为: P:申请资源，将信号量的值减一 V:释放资源，将信号量的值加一 P操作之后，若信号量的值仍大于等于零，则进程继续运行。若小于零，则将该进程放入等待序列中去。（若信号量为-3，则说明当前等待队列有3个进程等待访问）。 V操作之后，若信号量的值仍大于零（注意和P操作的区别），则进程继续运行。若小于等于零，则从等待队列中释放一个进程，然后再返回原进程或转进程调度。 同步互斥 同步即为进程之间相互协调，线
生产者消费者模型（从单个到多个）
weixin_45651194的博客
10-28 1959
生产者—消费者问题产生的条件 条件：生产者线程Pp和消费者线程Pc同步，各Pp（Pc）间互斥。 互斥：可以简单理解为，某一公共资源不允许两个及以上并发线程同时访问。 同步：因并发线程各自的执行结果互为对方执行条件（直接制约），使各进程按一定速度执行的过程。 生产者：增加资源，超出最大容量时停止生产，直到小于最大容量再重新开始生产。 消费者：消耗资源，容量为空时停止消耗，直到有了资源再重新开始消耗。 synchronized关键字 简单看一下，加对象锁的方式 synchronized(MyClass.cl
生产者-消费者问题（三个进程P1、P2、P3互斥使用一个包含N个单元的缓冲区）
super_iron_man的博客
10-07 9313
1.问题描述 2.问题分析 同步问题： （1）包含N个缓冲区单元，有空位置时才能写，即P1、P2、P3共享缓冲区空位，设置同步信号量empty； （2）存在奇数时才能读出奇数，P1、P2共享奇数缓冲区，设置同步信号量odd； （3）存在偶数时才能读出偶数，P1、P3共享偶数缓冲区，设置同步信号量even。 互斥问题： 三个进程彼此之间互斥的访问缓冲区，设置互斥信号量mutex。 3.注意事项 1.不要误认为是读者-写者问题，注意这里P2、P3之间也是互斥的，而读者之间的访问可以同时，这里只是单生产者多消费
C多线程：一生产者与多消费者
weixin_43632162的博客
11-19 1123
C多线程：一生产者与多消费者 /** 本例程是创建一个线程作为生产者，三个线程作为消费者 要求： a)为解决供多于求的情况，生产者一次只能生产一个，并等待消费者获取再生产下一个 b)消费者们防止资源竞争，不能同时获取一个数，即前一个消费者获取了一个数，下一个消费者要等待下一个数的产生 才可以获取 实现：加锁 + 信号信号量 + 条件判断 1)两个全局变量 num 和 flag，解决问题a)关键在于生产者每生产一个数，num加一，唯有当flag == num时，生 产者才可以生产下一个；消
生产者-消费者 java 一个生产者 三个消费者_(三)多个生产者多个消费者，给包子编号 ,用lock...
weixin_26720271的博客
03-03 253
packagecom.ProudceCustom;importjava.util.ArrayList;importjava.util.concurrent.locks.Condition;importjava.util.concurrent.locks.Lock;importjava.util.concurrent.locks.ReentrantLock;publicclassPro...
操作系统实验三——生产者-消费者问题
热门推荐
Luobuda的博客
12-20 1万+
生产者消费者问题 基本原理 在 Linux 操作系统用 C 实现经典同步问题：生产者—消费者，具体要求如下： ① 一个大小为 10 的缓冲区，初始状态为空。 ② 2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复 10 次。 ③ 2个消费者，随机等待一段时间，从缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复 10 次。 实验要求 本实验的主要目的是模拟操作系统中进程同步和互斥。在系统进程并发执行异步推进的过程中，由于资源共享和进程间合作而造
Java实现生产者与消费者（三）（多生产者多消费者）
v_yang_guang_v的专栏
04-07 1168
本文实现的是多生产者与多消费者的问题。如果直接在上篇文章中多加入一个生产者线程和一个消费者线程，则会产生一个生产者生产多个或者一个消费者消费多个的情况，解决办法是将consume和produce函数的最前面的一句if改为while，但是仅仅是这样的话又会产生死锁现象，最终将notify（）函数改为notifyall()函数，即每生产或者消费一个后都要将对方线程池的所有线程都唤醒。于是就可以实现多生
一个生产者生产产品，多个消费者同时获得产品
yinhua405的博客
08-27 718
#include &lt;iostream&gt; #include &lt;cstdlib&gt; #include &lt;unistd.h&gt; #include &lt;pthread.h&gt; #include &lt;semaphore.h&gt;   using namespace std;   struct{     pthread_rwlock_t rwlock;     i...
一个生产者 多个消费者
chengkairen2的专栏
04-20 601
将传统生产者消费者模式里的notify  换成了  notifyAll   import java.util.Collections; import java.util.LinkedList; import java.util.List; public class ProducerModular { public static void main(String[] args)...
操作系统算法之生产者消费者算法模拟
qq_43550476的博客
01-05 2742
操作系统算法之生产者消费者算法模拟 实验目的 本实验通过参考和调试生产者-消费者模拟程序，进一步认识进程并发执行的实质，加深对进程竞争关系，协作关系的理解，掌握使用信号量机制与P、V操作来实现进程的同步与互斥。进而完成本实验的要求。 实验要求 参考生产者-消费者模拟程序，完成下题要求： 桌子上有一空盘，允许存放一只水果。爸爸可向盘中放苹果，也可向盘中放桔子，儿子专等吃盘中的桔子，女儿专等吃盘中的苹果。规定当盘空时一次只能放一只水果供吃者取用。 （1）使用P、V操作实现爸爸、儿子、女儿三个并发进程的同步的算法
生产者消费者问题pv
最新发布
10-06
生产者消费者问题是指在多线程环境下，生产者和消费者之间共享一个有限的缓冲区，生产者将数据放入缓冲区，而消费者则从缓冲区中取出数据。这个问题的关键在于解决生产者和消费者之间的同步与互斥关系，以避免出现死锁情况。 在解决生产者消费者问题时，需要注意以下几点： 1. 当缓冲区为空时，消费者不能再进行消费。 2. 当缓冲区为满时，生产者不能再进行生产。 3. 消费者之间互斥，生产者之间互斥，但是生产者和消费者之间不影响。 4. 需要使用条件变量与互斥锁来实现同步与互斥操作。 回答完问题后，我提供几个相关问题： 相关问题： 1. 生产者消费者问题有哪些常见的解决方法？ 2. 在Java中，如何使用wait和notify来解决生产者消费者问题？ 3. 生产者消费者问题存在的主要挑战是什么？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

binary~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值