生产者和消费者(linux)

Linux下生产者消费者问题的C语言实现 操作系统的课程实验,在Linux下生产者-消费者问题的C语言实现。 阅读详情

同步

同步保证了每个执行流可以合理的访问每个临界资源

  • 同步的作用

当存在临界资源的时候,就直接获取临界资源;没有资源的时候,进行线程等待,等待其他线程让出临界资源,然后再通知等待线程。
等待线程之间再进行抢占式执行。

条件变量

当一个线程互斥的访问一个变量的时候,可能会出现在其他线程改变状态之前,他自己只能进行等待状态。
如果一个线程的任务是访问一个队列,当他发现这个队列是空的时候,他只能进行等待。等到其他线程将一个节点加入到这个队列中,然后通知等待队列(信号通知),这就要用到条件变量。

  • 实现原理

PCB等待队列 + 2个接口(等待接口,唤醒接口)

  • 执行流程

1.先判断当前线程有无资源可以利用,没有资源就进行调用等待接口进行线程等待,然后这个等待的线程就会被放在PCB等待队列中挂起等待,直到有其他线程来唤醒PCB等待队列中的线程。
2.当一个执行流生产了一个资源之后,调用唤醒接口。该唤醒接口的执行流就会通知PCB等待队列中被挂起的执行流,通知他们可以去访问临界资源,这些执行流彼此之间再进行抢占式执行

条件变量的接口

1.条件变量的定义
pthread_cond_t 结构体
在这里插入图片描述
2.初始化条件变量

#include <pthread.h>
//动态初始化 -- 需要调用销毁接口
int pthread_cond_init(pthread_cond_t *restrict cond,const pthread_condattr_t *restrict attr);
  • cond:传入条件变量的变量地址
  • attr:条件变量的属性,一般设置为NULL,让操作系统来默认分配
    在这里插入图片描述
//静态初始化 -- 不需要调用销毁接口
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

3.等待接口

#include <pthread.h>
//定时等待
int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
//一直等待
int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
  • cond:传入条件变量的变量地址
  • mutex:传入互斥锁变量的地址

4.唤醒接口

 #include <pthread.h>
//唤醒PCB等待队列中所有执行流
int pthread_cond_broadcast(pthread_cond_t *cond);
//唤醒PCB等待队列中至少一个执行流
int pthread_cond_signal(pthread_cond_t *cond);
  • cond:传入条件变量的变量地址

5.销毁条件变量

#include <pthread.h>

int pthread_cond_destroy(pthread_cond_t *cond);

可以释放掉添加变量的内存,防止内存泄漏。

简单实现一个生产者和一个消费者的模型

程序所需要的变量和函数

  • 临界资源:g_resource
  • 一把互斥锁 lock,一个临界资源 cond
  • 生产者线程 tid[1],消费者线程 tid[0]
  • 生产者线程任务函数 ProductStart(),消费者线程任务函数 ConsumeStart()

流程图:
在这里插入图片描述
代码:

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

//0 -- 当前没有临界资源  1 -- 当前有临界资源 
int g_resource = 0; //定义一个临界资源 

//定义互斥锁和条件变量 
pthread_mutex_t lock;//互斥锁 
pthread_cond_t cond;//条件变量 
//消费者线程任务
void* ConsumeStart(void* arg)
{
  (void*)arg;
  //让消费者一直消费 
  while(1)
  {
    //上锁,满足互斥条件,同一时间,一个临界资源只能被生成或者消费 
    pthread_mutex_lock(&lock);
    if(g_resource == 0)//如果没有临界资源 
    {
      //进行阻塞等待,阻塞等待的过程
      //1.把该线程的PCB放到PCB等待队列中 
      //2.取消该线程加的锁
      //3.等待进程被唤醒
      pthread_cond_wait(&cond,&lock);
    }
    sleep(1);
    g_resource--;//进行消费,每次-1 
    printf("i am consum pthread, now g_resource = [%d]\n",g_resource);
    pthread_mutex_unlock(&lock);//解锁 
    pthread_cond_signal(&cond);//通知生产者线程可以生产资源了 
  }
  return NULL;
}
//生产者线程任务
void* ProductStart(void* arg)
{
  (void*)arg;
  while(1)//生产者线程一直生产 
  {
    pthread_mutex_lock(&lock);//互斥条件,上锁 
    if(g_resource == 1)//如果有资源,生产者线程进入等待过程 
    {
      pthread_cond_wait(&cond,&lock);
    }
    sleep(1);
    g_resource++; //进行生产,每次+1 
    printf("i am Product thread, now g_resource = [%d]\n",g_resource);
    pthread_mutex_unlock(&lock);
    pthread_cond_signal(&cond);//通知消费者线程进行消费 
  }
  return NULL;
}

int main()
{
  //初始化互斥锁和条件变量
  pthread_mutex_init(&lock,NULL);
  pthread_cond_init(&cond,NULL);

  pthread_t tid[2];
  //消费者线程
  int ret = pthread_create(&tid[0],NULL,ConsumeStart,NULL);
  if(ret < 0)
  {
    perror("Consume pthread_create error");
    return 0;
  }

  //生产者线程 
  ret = pthread_create(&tid[1],NULL,ProductStart,NULL);
  if(ret < 0)
  {
    perror("Product pthread_create error");
    return 0;
  }
  int i = 0;
  //两个线程进行等待 
  for(i = 0; i < 2; i++)
  {
    pthread_join(tid[i],NULL);
  }

  //销毁互斥锁和条件变量 
  pthread_mutex_destroy(&lock);
  pthread_cond_destroy(&cond);
  return 0;
}

运行结果

在这里插入图片描述
可以发现是生产者生产一个资源,消费者就消费一个资源,一个生产者和一个消费者的模型就简单构造完毕了。
注意

  1. 模拟的资源是一个临界资源,在访问的时候需要满足互斥条件,就需要在访问的时候进行加锁和解锁,从而满足互斥。
  2. 如果不满足消费或者生产的条件的时候,就需要让这个线程进行等待,调用 pthread_cond_wait(&cond,&lock); 函数。在这个函数内部,会先把这个线程加入到PCB等待队列中,再对互斥锁进行解锁操作以便另一个线程可以互斥的访问临界资源,在解锁之后这个线程就陷入等待状态了。一直到该线程被唤醒后利用保存的程序计数器和上下文信息来恢复到之前的状态,再继续执行。
  3. 在生产和消费操作(+1,-1)之后,该线程的任务就是唤醒PCB等待队列中的另一个线程,让他进行消费或者生产操作,防止线程阻塞。如果生产者线程在生产完之后,不通知PCB等待队列去唤醒这个消费者线程,那么由于线程之间的抢占式执行,可能消费者线程此时还在等待状态(等待生产者生产资源),而生产者此时已经生产完资源,在他的想法中,已经有了资源,自己就等待消费了。此时生产者等待消费,消费者等待生产,就陷入了一个阻塞状态。
    在这里插入图片描述

pthread_cond_wait

函数接口
pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex)

该接口为啥要使用互斥锁

等待接口的作用就是让当前执行流进行等待,然后让其他执行流去访问临界资源,而临界资源在访问的时候,需要同时满足同步和互斥条件,否则就会出现二义性。
如果不使用互斥锁而单使用一个条件变量,也就是不满足互斥,只满足了同步,相当于不同的执行流在同一时刻可以访问临界资源。
所以说,在条件变量等待接口中需要用互斥锁来保证互斥属性,从而保证其他执行流在同一时刻访问临界资源的时候,只有一个执行流在访问临界资源。

等待接口的调用互斥锁的逻辑

  1. 将调用者线程的PCB放到PCB等待队列中
  2. 对该互斥锁进行解锁操作
  3. 等待其他线程再调用完临界资源后通知PCB等待队列,从而唤醒该执行流(唤醒执行流的情况需要看调用的是哪一个唤醒接口),把PCB等待队列中执行流移出PCB等待队列,然后进行抢锁操作。

这里又有两种情况:(无论抢没抢到互斥锁,执行流都已经移出了PCB等待队列)

  • 没有抢到互斥锁:这个执行流如果没有抢到互斥锁,就会卡在互斥锁的逻辑当中,也就是还是陷入等待状态。
    当他再次获取时间片的时候(下一次可以抢互斥锁时),就会通过上下文信息和程序计数器中恢复上一次执行时的场景,继续进行强互斥锁的逻辑,直到加锁成功,从等待接口返回。
  • 抢到了互斥锁:这个执行流如果抢到了互斥锁,就拥有了重新访问该临界资源的资格,可以直接从等待接口返回,然后顺序执行代码的逻辑。

等待接口的逻辑中,为啥要把调用者的PCB放到等待队列后才释放互斥锁

这是为了防止消费者线程先释放互斥锁后,被生产者线程抢在消费者线程进入PCB等待队列之前拿到互斥锁,并且执行生产逻辑后通知PCB等待队列。这个时候,消费者线程才进入PCB等待队列中,就可能发生没有生产者线程调用唤醒接口来唤醒PCB等待队列,因为此时已经生产了资源,而发生的阻塞现象。

在这里插入图片描述

多生产者多消费者模型

先将上面的程序,在主函数中分别增加一个生产者线程和一个消费者线程。
程序此时所需要的变量和函数

  • 临界资源:g_resource
  • 一把互斥锁 lock,一个临界资源 cond
  • 生产者线程 Producer_tid[],消费者线程 Consum_tid[],数组的大小都是2,THREADPRODUCER和THREADCONSUM 这两个宏来表示2
  • 生产者线程任务函数 ProductStart(),消费者线程任务函数 ConsumeStart()

主函数部分

   pthread_t Consum_tid[THREADCONSUM];//消费者线程
   pthread_t Producer_tid[THREADPRODUCE];//生产者线程
   int ret = 0;
   int i = 0;
   for(i = 0; i < THREADCONSUM; i++)
   {
     //消费者线程
     ret = pthread_create(&Consum_tid[i],NULL,ConsumeStart,NULL);
     if(ret < 0)
     {
       perror("Consume pthread_create error");
       return 0;
     }
   }
 
   for(i = 0; i < THREADPRODUCE; i++)
   {
     //生产者者线程
     ret = pthread_create(&Producer_tid[i],NULL,ProductStart,NULL);
     if(ret < 0)
     {
       perror("Product pthread_create error");
       return 0;
    }
   }

在这里插入图片描述
仅仅这样改变,就出现了不是同步访问资源的情况,消费者访问了没有的资源,很不合理。
原因:

  1. 两个消费者执行流先都阻塞在了等待接口,然后等到生产者线程生产完毕调用唤醒接口的时候,AB两个线程就从PCB等待队列中被释放。
  2. 消费者线程之前互相抢互斥锁,一个抢到,一个没抢到。假设A抢到了,然后顺序执行,最后在他释放锁资源的时候,B就拥有了时间片,然后抢到了互斥锁,继续顺序执行,此时就访问了不合理的资源

解决方案
把判断条件改为循环判断-- while

改掉之后发现问题还没有解决,程序会一直陷入等待的状态。
在这里插入图片描述
调用ps aux 和 pstack查看后发现线程都阻塞了
在这里插入图片描述
和上面的问题相比,这个现象就是多走了那一步。

  1. 首先,消费者A和消费者B都陷入了PCB等待队列中,然后由生产者进行生产资源,生产完毕后打印第一行数据,已经生产一个资源。
  2. 其次,消费者A和B被唤醒,开始抢这个互斥锁。假如抢到的是A,那么B就陷入等待中,但是此时消费者B是不在PCB等待队列中的。A顺序执行,打印消费的第二行。
  3. 之后A释放了锁资源,要拥有锁资源的线程开始抢占互斥锁,看打印的情况,此时应该是生产者抢到了互斥锁,然后生产资源,打印第三行。A线程释放之后,再次进入这个循环,还可以陷入等待,然后进入PCB等待队列中
  4. 最后释放锁资源的时候,应该是消费者抢到了这个互斥锁。此时再次判断有没有资源,发现没有,就陷入了等待逻辑。此时生产者AB,消费者AB(在PCB等待队列中,因为没有接到通知,所以他们认为当前是有资源的)都陷入了等待逻辑,程序卡死。

在这里插入图片描述
解决方法
自己调用自己的PCB等待队列,生产者用生产者PCB等待队列,消费者用消费者PCB等待队列
在这里插入图片描述
这样做法的好处
可以规避掉消费者消费完成之后,通知PCB等待队列的时候,唤醒的同样是一个消费者,导致所有线程都被卡死在等待的逻辑中。
这时生产者线程也接收不到消费者线程的唤醒接口,从而所有线程都卡死在了等待接口。

完善后打印的结果
在这里插入图片描述

源码

https://github.com/duchenlong/linux-text/blob/master/thread/conds.c

Linux-生产者消费者模型 生产者消费者模型一级目录二级目录三级目录一级目录 一级目录 二级目录 三级目录 一级目录 阅读详情

相关推荐

分别在windows和linux下用信号量解决生产者消费者问题

用信号量解决生产者消费者问题                                       实验目的   通过实验,掌握Windows和Linux环境下互斥锁和信号量的实现 方法,加深对临界区问题和进程同步机制的理解,同时熟悉利用Windows API和Pthread API进行多线程编程的方法。 实验内容   1.  在Windows操作系统上

yxq_fxd的博客 6190

Linux下实现生产者——消费者模型(代码)

涉及到的知识点: 链表操作、互斥量、条件变量、线程 代码说明: 代码是在Linux环境下运行,主要思路是在主函数中创建两个线程:生产者和消费者,将生产的产品保存在链表中。当没有产品时,消费者睡眠, 直到被生产者唤醒,当产品达到20个,生产者睡眠,知道被消费者唤醒。 实例代码 #include<stdlib.h> #include<assert.h> #include&l......

weixin_42031299的博客 4894

FPGA八股文(2)——笔试的FPGA问题汇总(持续更新)

常见FPGA笔试题的概念总结

居安士的博客 8915

Linux--生产者--消费者模型

Linux--生产者--消费者模型--BlockQueue--RingQueue队列的实现--线程池的模拟实现--读者 写者模型简介

c-and-c++ It*s my life 857

UE5动画革命:如何用Motion Matching技术让你的游戏角色动作更流畅(附实战配置)

本文深入解析了UE5中Motion Matching技术的实战配置与应用。通过对比传统动画状态机的局限,详细阐述了如何构建动画数据库、在UE5中配置Pose Search Database及动画蓝图,并探讨了与IK融合、性能优化等进阶策略。该技术能显著提升游戏角色动作的流畅度与真实感,是下一代动画解决方案的核心。

weixin_29075633的博客 866

MATLAB实战:Gardner定时同步算法实现与BER曲线优化指南

本文详细介绍了Gardner定时同步算法在MATLAB中的实现与优化方法,重点解析了算法原理、关键步骤实现及BER曲线绘制中的常见问题解决方案。通过优化参数设置和系统架构,提升数字通信系统的符号同步性能,为QPSK、QAM等调制系统提供实用参考。

weixin_29085865的博客 234

【Linux】生产者消费者模型 - 详解

生产者消费者模型/demo代码模拟两种生产消费场景/阻塞队列/环形队列

Hello_World_213的博客 1923

华为OD机试真题2026双机位C卷 Python&JS 语言 实现【主次关联成环警告】

在ICT运维领域,现网运维工程师面向对设备上报的众多告警,往往需要筛选出最主要的告警优先处理,次等级的告警或许为同一个根因导致的告警,处理优先级会放后或者不处理,这样就诞生出主次关联告警的概念。给定一系列告警的主次关联关系,判断是否存在如下情况:

MISAYAONE的博客 272

【Linux】生产者 消费者模型

针对上述情况,将if判断改为while循环,每一次被唤醒都要被检测,只有当队列真的是不满的情况,才会进行push。发生休眠实际上就是线程切换,当线程从休眠状态被唤醒时,因为是从临界区被切走的,所以继续从临界区内部执行。供货商可以集中生产的一大批的商品 放到超市中,让消费者随时随地来买,供货商就不生产了。如:若超市火腿肠满了,就应该让消费者先消费,若超市没有火腿肠了,就应该让生产者先生产。若队列中没有数据存在,则不该让消费者消费,若队列中数据满了,不该让生产者进行生产。

qq_62939852的博客 1038

-bash: mysql: 未找到命令

解决问题,😀

知识改变命运,ヾ(◍°∇°◍)ノ゙【求关注】 1352

uniapp - 实现移动端H5微信公众号网页内置浏览器中预览和下载word文档(doc)、excel表格(xls)、ppt文稿、pdf文档等文件,微信内部打开预览和下载到本地详教程,兼容安卓苹果手机

uni-app,微信公众号,h5,移动端,web平台端,网页,网站,Uniapp微信公众号H5网站,内置浏览器下载文档,如何在微信浏览器中预览office文件,word文档,excel文档,pdf文档,ppt文档,office,微信内置浏览器下载文件,下载文件,在微信浏览器里面实现下载任意文件,H5需要在微信浏览器中下载excel文件,UniApp实现网页在微信内置浏览器中下载文件详细教程,安卓点击下载会提示打开浏览器,后端返回流文件,如何解决无法下载文件,跳转至浏览器下载文件,发送到电脑微信,安卓,苹果,

🏆 前端领域优质创作者 1万+

【Linux】生产者消费者模型

多线程经典模型。

学了就忘是正常现象 2706

Python爬虫:招聘网站岗位要求、薪资与求职者数据爬取与分析

通过本文的教程,我们学习了如何通过 Python 编写招聘数据爬虫,爬取招聘网站上的岗位要求、薪资和求职者数据,并通过数据存储、清洗、分析和可视化,获取有价值的信息。网站如智联招聘、猎云网、前程无忧等,都提供了大量的招聘信息,包括岗位要求、薪资范围、工作经验、学位要求、招聘公司等。本文将介绍如何通过 Python 编写爬虫,爬取招聘网站上的岗位要求、薪资、求职者数据,并通过数据存储、分析和可视化等手段,为求职者或招聘者提供实用的信息和决策支持。通过循环抓取多个页面的数据,可以获取不同岗位的信息。

2201_76125261的博客 723

Linux——生产者消费者模型

摘要:生产者消费者模型解析 生产者消费者模型是一种经典的并发编程模型,通过引入缓冲区(超市)实现生产者和消费者的解耦。该模型提高了效率,支持忙闲不均,并通过互斥和同步机制保证线程安全。模型包含三种关系:生产者之间互斥、消费者之间互斥、生产者和消费者之间互斥+同步。文中实现了一个基于阻塞队列的版本,详细介绍了队列满/空时的阻塞机制、条件变量的使用以及伪唤醒问题的解决方法(使用while而非if判断)。最后给出了阻塞队列类的核心代码实现,包括入队、出队操作和线程同步机制。

二哈的博客 1238

AI快速变现之路,AI视频创作

初期投入$3000(工具订阅+样片制作),重点攻克跨境电商和本地生活服务市场。关注2025年AIGC视频工具的API降价趋势(如Pika企业版折扣可达50%),建议与云服务商签订长期合作协议。

qq_29896351的博客 1985

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Linux多进程实现生产者消费者问题

1. 任务简介 生产者消费者问题(Producer-consumer problem),也称有限缓冲问题(Bounded-buffer problem),是一个著名的进程同步问题的经典案例。它描述的是有一组生产者进程在生产产品,并将这些产品提供给一组消费者进程去消费。为使生产者进程和消费者进程能够并发执行,在这两者之间设置里一个具有nnn个缓冲区的缓冲池,生产者进程将他所生产的的产品放入一个缓冲区中;消费者进程可从一个缓冲区中取走产品并进行消费。尽管所有的生产者进程和消费者进程都是以异步方式运行的,但亡们之

BrilliantAntonio的博客 1万+

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

【Linux多线程】生产者消费者模型

本篇博客将会介绍Linux多线程中一个非常重要的模型——生产者消费者模型

m0_74215144的博客 1613

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Linux生产者消费者模型

模型核心:通过容器解耦生产者与消费者,支持并发与忙闲不均。实现关键:阻塞队列结合互斥锁与条件变量,确保互斥与同步。灵活性:可调整步调、唤醒条件,或扩展为复杂任务处理。

hu_yuchen的博客 789

Linux 生产者消费者模型

生产者和消费者彼此之间不直接通讯,而通过这个容器来通讯,所以,这个容器就相当于一个缓冲区,平衡了生产者和消费者的处理能力,这个容器实际上就是用来给生产者和消费者解耦的。

m0_73634434的博客 1207

【Linux】生产者消费者问题

生产者消费者问题,也被称作有限缓冲问题。可以描述为:两个或者更多的线程共享同一个缓冲区,其中一个或多个线程作为生产者会不断地向缓冲区中添加数据,另一个或者多个线程作为消费者” 从缓冲区中取走数据。

2302_76793428的博客 954
上一篇: 互斥锁与死锁(linux多线程)
下一篇: MySQL的使用
_ 菜 -∞
博客等级 码龄8年 230粉丝 146原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值