linux下C语言实现生产者-消费者问题实现

最新推荐文章于 2024-05-22 11:14:53 发布
最新推荐文章于 2024-05-22 11:14:53 发布
阅读量2.1k 收藏 49
点赞数 6
分类专栏： 操作系统 文章标签： 多线程 操作系统 c语言 linux
原文链接：https://blog.csdn.net/ruixj/article/details/4906218
版权

linux下C语言实现生产者-消费者问题实现


整合代码： 整个程序代码

使用信号量解决有限缓冲区生产者/消费者问题(伪代码)

producer :							                   consumer:
	while(true){				                          while(true){
		/*生产 v*/											while(in == out)(不做任何事);
		while((in + 1)% n == out)(不做任何事)；					w = b[out];
		b[in] = v;												out = (out + 1) % n;
		in = (in + 1) % n;										/*消费 w*/
	}													  }

const int sizeofbuffer = /*缓冲区大小*/
semaphore s = 1, n = 0, e = sizeofbuffer;
void producer()											void consumer()
{														{
	while(true){											while(true){
		produce();  /*生产*/									semWait(n); /*空不取*/
		semWait(e); /*满不放*/									semWait(s); /*互斥信号量*/
		semWait(s); /*互斥信号量*/								take();/*w = b[out];
																		 out = (out + 1) % n;*/
		append();   /*b[in] = v;*/							    semSignal(s);
	    		    /*in = (in + 1) % n;*/						semSingal(e);
		semSignal(s);											consume()   /*消费*/
		semSingal(n);										}
		}
}														}

void main()
{
	parbegin(producer, consumer);
}

一、main()

int main()
{
pthread_t id1[producerNumber]; // 声明生产者线程的ID数组
pthread_t id2[consumerNumber]; // 声明消费者线程的ID数组
int i;
int ret1[producerNumber];
int ret2[consumerNumber];
 
// 初始化同步信号量
int ini1 = sem_init(&empty_sem, 0, M); 
	// 原型为:extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
	// 第一个参数：sem为指向信号量结构的一个指针；
	// 第二个参数：pshared==0确保只能为当前的进程的所有线程共享
	// 第三个参数：value为信号量的初始值
int ini2 = sem_init(&full_sem, 0, 0); // 同上初始化的描述
if(ini1 && ini2 != 0) //初始化失败
{
   printf("sem init failed \n");
   exit(1);
}
 
//初始化互斥信号量的函数pthread_mutex_init(); 
int ini3 = pthread_mutex_init(&mutex, NULL); 
       // 抽象的锁类型的结构；
       //函数原型：int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr); 以动态方式创建互斥锁
       // 第一个参数：为指向互斥信号量结构的一个指针
       // 第二个参数： 指定了新建互斥锁的属性，NULL表明使用默认的互斥锁属性（快速互斥锁）
if(ini3 != 0)
{
   printf("mutex init failed \n");
   exit(1);
}
// 创建producerNumber个生产者线程
for(i = 0; i < producerNumber; i++)
{
   ret1[i] = pthread_create(&id1[i], NULL, product, NULL);
   // 用ret1[]数组记录是否创建线程成功，因为pthread_create()函数返回值为int类型；若返回值为0表示创建成功，否则返回出错的编号
   // 函数原型：int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
   // 第一个参数：为指向线程标识符（ID号）的指针
   // 第二个参数： 用来设置线程的属性
   // 第三个参数： 线程运行函数的地址
   // 第四个参数： 运行函数的参数
   if(ret1[i] != 0)
   {
    printf("product%d creation failed \n", i);
    exit(1);
   }
}
//创建consumerNumber个消费者线程
for(i = 0; i < consumerNumber; i++)
{
   ret2[i] = pthread_create(&id2[i], NULL, prochase, NULL);
   if(ret2[i] != 0)
   {
    printf("prochase%d creation failed \n", i);
    exit(1);
   }
}
//销毁线程
for(i = 0; i < producerNumber; i++)
{
   pthread_join(id1[i],NULL);
   //pthread_join()函数来使主线程阻塞以等待其他线程退出
}
 
for(i = 0; i < consumerNumber; i++)
{
  pthread_join(id2[i],NULL);
}
 
exit(0);
}

二、使用步骤

1.引入库

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>    //windows下用windows.h
#include <pthread.h>   // 实现多线程的头文件
#include <semaphore.h> // 实现信号量定义的头文件 
 
#define producerNumber 3   // 生产者的数目
#define consumerNumber 4   // 消费者的数目
#define M 6 // 缓冲区数目
 
int in = 0;   // 生产者放置产品的位置
int out = 0; // 消费者取产品的位置
 
int buff[M] = {0}; // 缓冲初始化为0， 开始时没有产品
 
sem_t empty_sem; // 信号量的数据类型为结构sem_t，它本质上是一个长整型的数,同步信号量， 当满了时阻止生产者放产品
sem_t full_sem;   // 同步信号量， 当没产品时阻止消费者消费
pthread_mutex_t mutex; // 互斥信号量， 一次只有一个线程访问缓冲
 
int producer_id = 0;   // 生产者id
int consumer_id = 0; // 消费者id

2.创建生产者/消费者的函数

代码如下）：


/* 打印缓冲情况 */
void print()
{
int i;
for(i = 0; i < M; i++)
   printf("%d ", buff[i]);
printf("\n");
}
 
/* 生产者方法 */
void *product()
{
int id = ++producer_id;
 
while(1)
{
   // 用sleep的数量可以调节生产和消费的速度，便于观察
   sleep(1);
   //sleep(1);
  
   sem_wait(&empty_sem); // 满不放；书本上的semWait(e=M(缓冲区大小))操作；
   pthread_mutex_lock(&mutex); // 实现互斥
  
   in = in % M;
   buff[in] = rand()%10;
   printf("生产者%d向%d号缓冲区放入了一个数据%d: \t", id, in, buff[in]);  
   print();  
   ++in;
  
   pthread_mutex_unlock(&mutex);
   sem_post(&full_sem);
}
}
 
/* 消费者方法 */
void *prochase()
{
int id = ++consumer_id;
while(1)
{
   // 用sleep的数量可以调节生产和消费的速度，便于观察
   sleep(1);
//sleep(1);
  
   sem_wait(&full_sem); // 空不取
   pthread_mutex_lock(&mutex); // 实现互斥
  
   out = out % M;
   printf("消费者%d从%d号缓冲区取出一个数据%d: \t", id, out, buff[out]);
  
   buff[out] = 0;
   print();
   ++out;
  
   pthread_mutex_unlock(&mutex);
   sem_post(&empty_sem);
}
}

总结(实现代码)

用到了<pthread.h>和<semaphore.h>两个头文件内函数，本来还以为会很难，但查找资料的时候从别人哪里看到了这两种头文件就发现其实没有想象的那么难。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>    //windows下用windows.h
#include <pthread.h>   // 实现多线程的头文件
#include <semaphore.h> // 实现信号量定义的头文件 

#define producerNumber 3   // 生产者的数目
#define consumerNumber 4   // 消费者的数目
#define M 6 // 缓冲区数目

int in = 0;   // 生产者放置产品的位置
int out = 0; // 消费者取产品的位置

int buff[M] = {0}; // 缓冲初始化为0， 开始时没有产品

sem_t empty_sem; // 信号量的数据类型为结构sem_t，它本质上是一个长整型的数,同步信号量， 当满了时阻止生产者放产品
sem_t full_sem;   // 同步信号量， 当没产品时阻止消费者消费
pthread_mutex_t mutex; // 互斥信号量， 一次只有一个线程访问缓冲

int producer_id = 0;   // 生产者id
int consumer_id = 0; // 消费者id

/* 打印缓冲情况 */
void print()
{
int i;
for(i = 0; i < M; i++)
   printf("%d ", buff[i]);
printf("\n");
}

/* 生产者方法 */
void *product()
{
int id = ++producer_id;

while(1)
{
   // 用sleep的数量可以调节生产和消费的速度，便于观察
   sleep(1);
   //sleep(1);
  
   sem_wait(&empty_sem); // 满不放；书本上的semWait(e=M(缓冲区大小))操作；
   pthread_mutex_lock(&mutex); // 实现互斥
  
   in = in % M;
   buff[in] = rand()%10;
   printf("生产者%d向%d号缓冲区放入了一个数据%d: \t", id, in, buff[in]);  
   print();  
   ++in;
  
   pthread_mutex_unlock(&mutex);
   sem_post(&full_sem);
}
}

/* 消费者方法 */
void *prochase()
{
int id = ++consumer_id;
while(1)
{
   // 用sleep的数量可以调节生产和消费的速度，便于观察
   sleep(1);
//sleep(1);
  
   sem_wait(&full_sem); // 空不取
   pthread_mutex_lock(&mutex); // 实现互斥
  
   out = out % M;
   printf("消费者%d从%d号缓冲区取出一个数据%d: \t", id, out, buff[out]);
  
   buff[out] = 0;
   print();
   ++out;
  
   pthread_mutex_unlock(&mutex);
   sem_post(&empty_sem);
}
}

int main()
{
pthread_t id1[producerNumber]; // 声明生产者线程的ID数组
pthread_t id2[consumerNumber]; // 声明消费者线程的ID数组
int i;
int ret1[producerNumber];
int ret2[consumerNumber];

// 初始化同步信号量
int ini1 = sem_init(&empty_sem, 0, M); 
	// 原型为:extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
	// 第一个参数：sem为指向信号量结构的一个指针；
	// 第二个参数：pshared==0确保只能为当前的进程的所有线程共享
	// 第三个参数：value为信号量的初始值
int ini2 = sem_init(&full_sem, 0, 0); // 同上初始化的描述
if(ini1 && ini2 != 0) //初始化失败
{
   printf("sem init failed \n");
   exit(1);
}

//初始化互斥信号量的函数pthread_mutex_init(); 
int ini3 = pthread_mutex_init(&mutex, NULL); 
       // 抽象的锁类型的结构；
       //函数原型：int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr); 以动态方式创建互斥锁
       // 第一个参数：为指向互斥信号量结构的一个指针
       // 第二个参数： 指定了新建互斥锁的属性，NULL表明使用默认的互斥锁属性（快速互斥锁）
if(ini3 != 0)
{
   printf("mutex init failed \n");
   exit(1);
}
// 创建producerNumber个生产者线程
for(i = 0; i < producerNumber; i++)
{
   ret1[i] = pthread_create(&id1[i], NULL, product, NULL);
   // 用ret1[]数组记录是否创建线程成功，因为pthread_create()函数返回值为int类型；若返回值为0表示创建成功，否则返回出错的编号
   // 函数原型：int pthread_create(pthread_t *restrict tidp,const pthread_attr_t *restrict_attr,void*（*start_rtn)(void*),void *restrict arg);
   // 第一个参数：为指向线程标识符（ID号）的指针
   // 第二个参数： 用来设置线程的属性
   // 第三个参数： 线程运行函数的地址
   // 第四个参数： 运行函数的参数
   if(ret1[i] != 0)
   {
    printf("product%d creation failed \n", i);
    exit(1);
   }
}
//创建consumerNumber个消费者线程
for(i = 0; i < consumerNumber; i++)
{
   ret2[i] = pthread_create(&id2[i], NULL, prochase, NULL);
   if(ret2[i] != 0)
   {
    printf("prochase%d creation failed \n", i);
    exit(1);
   }
}
//销毁线程
for(i = 0; i < producerNumber; i++)
{
   pthread_join(id1[i],NULL);
   //pthread_join()函数来使主线程阻塞以等待其他线程退出
}

for(i = 0; i < consumerNumber; i++)
{
  pthread_join(id2[i],NULL);
}

exit(0);
}

pthread_create、pthread_join、pthread_mutex_init 、pthread_mutex_lock、pthread_mutex_unlock用法from:函数的使用

调试截图：
在这里插入图片描述

闲人想忙人Mr. jiang
关注
  • 6
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
C语言实现生产者消费者问题
05-27
C语言实现生产者消费者问题，分配具有n个缓冲区的缓冲池，作为共享资源。 定义两个资源型信号量empty 和full，empty信号量表示当前空的缓冲区数量，full表示当前满的缓冲区数量。 定义互斥信号量mutex，当某个进程...
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 ...
电子科大操作系统：实验一生产者消费者问题
m0_73672331的博客
05-08 876
同步和通信：线程标识符用于各种 pthreads 函数中，如 pthread_join、pthread_detach 或 pthread_cancel，这些函数可能需要知道它们操作的确切线程。对一个互斥量进行初始化：int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr);标识线程：每个线程都需要一个唯一的标识符，这样你就可以区分不同的线程，特别是在进行线程同步或需要获取特定线程的状态时。
linux操作系统-综合编程
m0_58540923的博客
07-30 1773
linux操作系统-综合编程
Linux c语言实现一个生产者和消费者
最新发布
海涛高软
05-22 323
这段代码实现了一个简单的生产者-消费者模型，其中包含了一个有限缓冲区。它使用了条件变量来同步生产者和消费者，确保在缓冲区为空或为满时不会消耗或生产数据，从而避免了竞态条件。这个例子教会了如何在Linux环境下使用C语言编写并发程序。FR：徐海涛（hunk Xu)
Linux系统下实现生产者消费者问题
qq_36782429的博客
07-25 526
linux系统下实现生产者消费者问题。
Linux学习（27）：生产者消费者模型、条件变量、信号量
weixin_43870645的博客
04-15 154
使用线程通信的条件变量和信号量实现生产者-消费者模型
进程调度：生产者/消费者问题（信号量方式）伪代码
小枫哥的博客
04-03 1161
代码来源：中国大学Mooc《计算机操作系统》蒲晓蓉
生产者消费者伪码_记录型信号量解决生产者消费者问题伪代码，描述每一步具体执行过程...
weixin_31589331的博客
01-14 462
Varmutex,empty,full:semaphore:=1,n,0;buffer:array[0,...,n-1]ofitem;in,out:integer:=0,0;beginparbeginproceducer:beginrepeat...produceranitemnextp;...wait(empty);wait(mutex...Var mutex,empty,full:semaph...
Linux环境下C语言实现生产者消费者问题的代码
03-11
在Linux下完整C语言实现生产者消费者问题的代码。其中涉及信号量、多线程、GCC编译、PV操作等基础知识。Linux下通过gcc - o yy xxx.c -pthread，再通过./yy即可运行。
使用多线程程序模拟实现单生产者/多消费者问题（Linux下C语言）。
11-25
使用多线程程序模拟实现单生产者/多消费者问题。 要求“生产者”随机产生一个整数，“消费者 1”将这个整数加 1 后输出，“消 费者 2”将这个整数加 2 后输出，“消费者 3”将这个整数加 3 后输出，“消 费者 4”将...
（Linux C）利用多进程或多线程模拟实现生产者/消费者问题
02-11
在IT领域，生产者/消费者问题是并发编程中的一个经典模型，用于展示同步和通信的概念。在Linux环境下，C语言可以通过多进程或多线程来实现这个模型。本篇将深入探讨如何利用这两种方法来模拟生产者/消费者问题，并...
用c语言实现“生产者和消费者”问题
weixin_52451652的博客
04-18 8092
实验要求：要求程序运行时，按任意键停止，显示各种信息 #include <stdio.h> #include<stdlib.h> #include<time.h> int mutex=1; int empty=10; int full=0; int buf[10]; int front=0,rear=0; int i; //p操作 .申请 void p(int *x) { *x=(*x)-1; } //v操作 .释放 void v(int *x) { *x=
生产者-消费者问题及C语言实现
热门推荐
小弹弹的专栏
07-10 1万+
问题描述 生产者-消费者问题是最著名的进程同步问题。它描述了一组生产者与一组消费者，它们共享一个有界缓冲池，生产者向池中投入产品，消费者从池中取得产品。假定缓冲池中有 N 个缓冲区，每个缓冲区只能存放一个类型为 item 的产品，而所有的生产者和消费者是相互等效的，则需要为该问题设置三个信号量：互斥信号量 mutex，用于实现对缓冲池的互斥访问，其初值为 1；资源信号量 empty，用来表示
Linux C系统编程——使用信号量实现生产者，消费者问题（两分钟搞明白）
m0_56145255的博客
10-21 5439
信号量和信号不是同一个东西。 信号量 ：指的是semaphore，相当于设置初始值为N的互斥量， N就表示同时访问的线程数（针对的是线程同步问题） 信号：指的是用来实现进程与进程之间，进程与线程之间的一种异步机制。（针对的是异步处理的问题） 实验源码 下面展示一些 内联代码片。 重在理解思路 #include <unistd.h> #include <stdio.h> #include <stdlib.h> #include <pthread.h> #inc
Linux C语言线程解决生产者与消费者
weixin_46068274的博客
09-13 1792
Linux 生产者与消费者 通过线程解决！！！
【Linux系统编程（十四）】生产者和消费者问题
K3169的博客
11-05 788
生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了共享固定大小缓冲区的两个线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。
操作系统知识（第三章 内存管理）2
SJ_Sniper的博客
02-12 2653
第三章 内存管理。非连续分配管理方式：页式存储方式、段式存储方式、段页式存储方式。（包括三者的内存空间划分、进程空间划分、内存空间与进程空间的对应关系、所需表目、所需寄存器、地址映射等）
Linux下使用c语言，用多线程实现生产者-消费者问题
04-22
好的，理解了你的问题。生产者-消费者是一个经典的线程同步问题，需要使用线程锁和条件变量来实现。 首先，我们需要定义一个缓冲区，用来存储生产者生产的数据。缓冲区可以是一个队列或数组，缓冲区大小可以预先定义。 我们需要两个线程函数：生产者函数和消费者函数。生产者函数负责将数据写入缓冲区，消费者函数负责从缓冲区中读取数据。 我们还需要定义一些变量来实现线程同步，包括互斥锁和条件变量。 下面是一个简单的代码示例： ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define BUFFER_SIZE 10 pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; //定义互斥锁 pthread_cond_t cond_producer = PTHREAD_COND_INITIALIZER; //定义生产者条件变量 pthread_cond_t cond_consumer = PTHREAD_COND_INITIALIZER; //定义消费者条件变量 int buffer[BUFFER_SIZE]; //定义缓冲区 int count = 0; //定义缓冲区计数器 void *producer(void *arg) //生产者函数 { int i; for (i = 0; i < 20; i++) //生产20个数据项 { pthread_mutex_lock(&lock); //加锁 while (count == BUFFER_SIZE) //缓冲区满，等待消费者消费 pthread_cond_wait(&cond_producer, &lock); buffer[count] = i; count++; printf("Producer produced item %d\n", i); pthread_cond_signal(&cond_consumer); //唤醒等待的消费者 pthread_mutex_unlock(&lock); //解锁 } pthread_exit(NULL); } void *consumer(void *arg) //消费者函数 { int i, item; for (i = 0; i < 20; i++) //消费20个数据项 { pthread_mutex_lock(&lock); //加锁 while (count == 0) //缓冲区空，等待生产者生产 pthread_cond_wait(&cond_consumer, &lock); item = buffer[count-1]; count--; printf("Consumer consumed item %d\n", item); pthread_cond_signal(&cond_producer); //唤醒等待的生产者 pthread_mutex_unlock(&lock); //解锁 } pthread_exit(NULL); } int main(int argc, char **argv) { pthread_t tid_producer, tid_consumer; pthread_create(&tid_producer, NULL, producer, NULL); pthread_create(&tid_consumer, NULL, consumer, NULL); pthread_join(tid_producer, NULL); pthread_join(tid_consumer, NULL); return 0; } ``` 以上代码使用了互斥锁和条件变量来实现生产者-消费者同步。具体实现可以参考代码注释。 希望对你有帮助！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值