生产者消费者问题3 ---- 经典同步互斥 （3个文件，涉及共享内存，每个消费者可以拿多次，如果一次没拿到全部想要的，还可以等待生产者生产之后又去拿）

最新推荐文章于 2021-05-16 02:16:02 发布
最新推荐文章于 2021-05-16 02:16:02 发布
阅读量245 收藏 1
点赞数 2
分类专栏： 操作系统学习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sumisu666/article/details/105774270
版权

生产者消费者问题，三个.c文件实现

procon.c producer.c consumer.c
此篇程序要满足：
所有消费者都有足够产品消费。
程序不能打击来的早的消费者，就是说，消费者暂时拿不到足够产品，程序不应该剥夺他的消费权，而是应该让他等，等到货架上有足够的产品再消费。

还有有一篇我写的兄弟文章，两者相似，只是消费者有点不同-----------链接: 生产者消费者问题2 ---- 经典同步互斥 （3个文件，涉及共享内存，每个消费者只能拿一次，如果一次没拿到全部想要的，没有第二次机会拿）.

通过procon.c来控制producer.c和consumer.c的运行。
下图是我整个文件里面的文件，方便大家更能理解。
在这里插入图片描述

//procon.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/wait.h>  //wait()

#define M_KEY  5201
#define E_KEY  5207
#define T_KEY  5208
#define S_KEY  5209
int mutex,empty,towel,soap;  //声明信号量

#define N 32   //32个货架
#define MAX_PROCESSES 32 //最大进程数

#define SHMKEY 2020   //共享区关键字

 
int main(int argc,char **argv)
{ 
    int i, status;
    pid_t pid, wpid;


int shmid;  //共享区标识符
char *addr;//共享内存的首地址

//创建共享内存
  shmid = shmget(SHMKEY,1024,0660|IPC_CREAT);
  addr = (char *)shmat(shmid,0,0);
  memset(addr,0,1024); //共享区清0

  FILE *fp; 
  //fp=fopen("/home/ssm/shiyan2-2/pc.csv","r"); //打开文件
  fp=fopen("./pc.csv","r"); //打开文件
  if( fp == NULL ){
     printf("打开数据文件失败!\n");  
    return 0;  
  }


  char process[100],bride[100],name[100]; //读取的文件数据存放变量
  char tm[16];
  char count[16]; 
  
    mutex=semget(M_KEY,1,IPC_CREAT|0660);//创建信号量
    semctl(mutex,0,SETVAL,1); //初值1
    
    empty=semget(E_KEY,1,IPC_CREAT|0660);//创建空信号量
    semctl(empty,0,SETVAL,N); //初值N
    
    towel=semget(T_KEY,1,IPC_CREAT|0660);//创建满信号量
    semctl(towel,0,SETVAL,0); //初值0

    soap=semget(S_KEY,1,IPC_CREAT|0660);//创建满信号量
    semctl(soap,0,SETVAL,0); //初值0

  
//读文件创建相应进程/

	  while( !feof(fp))
	  {
	     
	  if(fscanf( fp, " %[^,],%[^,],%[^,],%[^,],%s%*c", process, tm, bride, name, count ) != 5) break;
	     printf( "%s %s %s %s %s\n", process, tm, bride, name, count ); 
	     pid=fork();
            if(pid==0){
                //sprintf(num, "%d", i);
                if(strstr(process, "生产者") !=NULL)  
                    execlp("./producer", tm, process, bride, name, count, NULL); //执行producer程序                        
                else execlp("./consumer", tm, process, bride, name, count, NULL);//执行consumer程序		     
                exit(0);
               }
	  }  

  fclose( fp );  

        if(pid>0) {
		while ((wpid = wait(&status)) > 0); //等待所有子进程结束
		printf("所有进程都已结束。\n");
		//结束之前：扫尾工作
		shmdt(addr); //断开共享区
                shmctl(shmid,IPC_RMID, 0); //删除共享区

                semctl(mutex, 0, IPC_RMID); //删除信号量
	        semctl(empty, 0, IPC_RMID); //删除信号量
	        semctl(towel, 0, IPC_RMID); //删除信号量
                semctl(soap, 0, IPC_RMID); //删除信号量
	  }
	         
  return 0;  
}  



//consumer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/time.h>  //for gettimeofday()

#define M_KEY  5201
#define E_KEY  5207
#define T_KEY  5208
#define S_KEY  5209
int mutex,empty,towel,soap;  //声明信号量

#define N  32    //最大货架数
#define MAX_PROCESSES  32  //最大进程数

#define SHMKEY 2020   //共享区关键字

//货架结构体
typedef struct Shelf_t{
    char name[32];//产品名，一个utf-8汉字占3字节
}Shelf;


int P(int sid) //P操作
{
    struct sembuf sb={0,-1,0};
    return semop(sid, &sb, 1);
}
 
int V(int sid) //V操作
{
    struct sembuf sb={0,1,0};
    return semop(sid, &sb, 1);
};



int main(int argc,char **argv)
{
    int shmid; //共享区标识符
    char *addr; //共享区地址
    Shelf *sf; //货架指针
    int i,j;
    int start;

    mutex=semget(M_KEY,1,IPC_CREAT|0660);//创建信号量
    //semctl(mutex,0,SETVAL,1); //初值1
    
    empty=semget(E_KEY,1,IPC_CREAT|0660);//创建空信号量
    //semctl(empty,0,SETVAL,N); //初值N
    
    towel=semget(T_KEY,1,IPC_CREAT|0660);//创建满信号量
    //semctl(towel,0,SETVAL,0); //初值0

    soap=semget(S_KEY,1,IPC_CREAT|0660);//创建满信号量
    //semctl(soap,0,SETVAL,0); //初值0

    struct timeval tv,tv0;
    gettimeofday(&tv0, NULL);
    tv.tv_sec/=10; tv.tv_sec*=10; //初始时间tv0，去个位秒数

    //创建共享区
    shmid = shmget(SHMKEY,1024,IPC_CREAT|0660);
    addr = (char*)shmat(shmid,0,0);
    sf = (Shelf *)addr;
 
    start=atoi(argv[0]); //开始时间

//---------------------互斥访问货架------------------------------------------------------------------------

if(strcmp(argv[3],"香皂") == 0) {
    //P(soap);   //查满货架
    //P(mutex);  //申请访问货架区
    printf("\n%s到达, 计划消费%s %d个\n\n",argv[1],argv[3],atoi(argv[4])); 

    for(i = 0;i < atoi(argv[4]);i++) {
        //找满货架
	    P(soap);
	    P(mutex);
        for(j = 0;j < N;j++) {
            if(strstr(sf[j].name,"香皂") != NULL) {
                gettimeofday(&tv, NULL);
                tv.tv_sec-=tv0.tv_sec;
                printf("取货时间%d.%d:  %s, 货架号:%d  拿取品牌:%s  名称:%s\n",(int)tv.tv_sec, (int)tv.tv_usec, argv[1], j, argv[2], sf[j].name); 
                sf[j].name[0] = '\0'; //取出产品后,货架置空
                //V(mutex);   //释放货架区 <<<< 此处不合适，j为1,2...时,mutex信号量不能保证互斥
                //V(empty);   //发空货架消息
                break;
             }
        }
	    V(mutex);
	    V(empty);
        if(j == N) 
        {
             printf("%s找香皂失败\n",argv[1]);
        }
    }
}


//    
  
if(strcmp(argv[3],"毛巾") == 0) {
    //P(towel);            //查满货架
    //P(mutex);         //申请访问货架区
    printf("\n%s到达, 计划消费%s %d个\n\n",argv[1],argv[3],atoi(argv[4])); 

    for(i = 0;i < atoi(argv[4]);i++) {
	//找满货架
    P(towel);         //查满货架
    P(mutex);         //申请访问货架区
        for(j = 0;j < N;j++) {
            if(strstr(sf[j].name,"毛巾") != NULL) {
                gettimeofday(&tv, NULL);
                tv.tv_sec-=tv0.tv_sec;
                printf("取货时间%d.%d:  %s, 货架号:%d  拿取品牌:%s  名称:%s\n",(int)tv.tv_sec, (int)tv.tv_usec, argv[1], j, argv[2], sf[j].name); 
                sf[j].name[0] = '\0'; //取出产品后,货架置空
                //V(mutex);     //释放货架区  <<<< 此处不合适
                //V(empty);     //发空货架消息
                break;
            }
	}
	V(mutex);
	V(empty);
	if(j == N) 
        {
             printf("%s找毛巾失败\n",argv[1]);
        }
    }
}




shmdt(addr); //断开共享区

return 0;   
}



//producer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/time.h>  //for gettimeofday

#define M_KEY  5201
#define E_KEY  5207
#define T_KEY  5208
#define S_KEY  5209
int mutex,empty,towel,soap;  //声明信号量

#define N  32    //最大货架数
#define MAX_PROCESSES  32  //最大进程数

#define SHMKEY 2020   //共享区关键字

//货架结构体
typedef struct Shelf_t{
    char name[32];//产品名，一个utf-8汉字占3字节
}Shelf;


int P(int sid) //P操作
{
    struct sembuf sb={0,-1,0};
    return semop(sid, &sb, 1);
}
 
int V(int sid) //V操作
{
    struct sembuf sb={0,1,0};
    return semop(sid, &sb, 1);
};



int main(int argc,char **argv)
{
    int shmid; //共享区标识符
    char *addr; //共享区地址
    Shelf *sf; //货架指针
    int i,j;
    int start;

    mutex=semget(M_KEY,1,IPC_CREAT|0660);//创建信号量
    //semctl(mutex,0,SETVAL,1); //初值1
    
    empty=semget(E_KEY,1,IPC_CREAT|0660);//创建空信号量
    //semctl(empty,0,SETVAL,N); //初值N
    
    towel=semget(T_KEY,1,IPC_CREAT|0660);//创建满信号量
    //semctl(towel,0,SETVAL,0); //初值0

    soap=semget(S_KEY,1,IPC_CREAT|0660);//创建满信号量
    //semctl(soap,0,SETVAL,0); //初值0


    struct timeval tv,tv0;
    gettimeofday(&tv0, NULL);
    tv.tv_sec/=10; tv.tv_sec*=10; //初始时间tv0，去个位秒数

    //创建共享区
    shmid = shmget(SHMKEY,1024,IPC_CREAT|0660);
    addr = (char*)shmat(shmid,0,0);
    sf = (Shelf *)addr;
 
    start=atoi(argv[0]); //开始时间
    sleep(start); //挨过开始时间

//-------------------------------------------互斥访问货架-------------------------------------------------------------------

P(empty);       //查空货架
P(mutex);      //申请访问货架区

printf("\n%s到达, 计划生产%s %d个\n\n",argv[1],argv[3],atoi(argv[4])); 
   
/ 
 if(strcmp(argv[3],"毛巾") == 0) {
   for(i = 0;i < atoi(argv[4]);i++) {
	//找空货架
       for(j = 0;j < N;j++) {
           if(sf[j].name[0] == '\0') {
               gettimeofday(&tv, NULL);
               tv.tv_sec-=tv0.tv_sec;
               strcpy(sf[j].name,argv[3]); //放入货架
               printf("%d.%d: %s  货架号:%d  放置品牌:%s  名称:%s\n",(int)tv.tv_sec,(int)tv.tv_usec, argv[1], j, argv[2], argv[3]); 
               //V(mutex);  //释放货架区  <<<<此处有漏洞，j为1,2,...时不能保证互斥
               V(towel); //空毛巾区
               break;
           }
	}
	if(j == N) 
	{
            printf("%s找空货架失败\n",argv[1]);
        }
    }
}


else if(strcmp(argv[3],"香皂") == 0) {
   for(i = 0;i < atoi(argv[4]);i++) {
	//找空货架
       for(j = 0;j < N;j++) {
          
           if(sf[j].name[0] == '\0') {
               gettimeofday(&tv, NULL);
               tv.tv_sec-=tv0.tv_sec;
               strcpy(sf[j].name,argv[3]); //放入货架
               printf("%d.%d: %s  货架号:%d  放置品牌:%s  名称:%s\n",(int)tv.tv_sec,(int)tv.tv_usec, argv[1], j, argv[2], argv[3]); 
               //V(mutex);      //释放货架区      
               V(soap); //空香皂区
               break;
           }
	}
	if(j == N) 
	{
	    printf("%s找空货架失败\n",argv[1]);
        }
    }
}
V(mutex);
   


shmdt(addr); //断开共享区


return 0;   
}

文件名为Makefile，功能：简便的一次性编译多个.c文件
使用方法：命令行输入 make 即可

//Makefile

#Makjfile1:wq
target: producer consumer procon
producer: producer.c
	gcc -pthread producer.c -o producer
consumer: consumer.c
	gcc -pthread consumer.c -o consumer
procon: procon.c
	gcc -pthread procon.c -o procon
clean: producer consumer procon
	rm -f producer consumer procon

结果分析：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

苏米素
关注
专栏目录
Linux信号量与互斥锁解决生产者与消费者问题
qq_45829112的博客
11-27 2465
先来看什么是生产者消费者问题： 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据
用多进程同步方法解决生产者-消费者问题
07-09
这是一个操作系统的课程设计 ，关于在linux下用多进程同步方法解决生产者-消费者问题。 有论文和源码
经典例题：生产者/消费者
小心星的博客
02-07 630
线程通信的应用：经典例题：生产者/消费者 package com.day0207_2; /** * 线程通信的应用：经典例题：生产者/消费者 * * 生产者（Productor）将产品交给店员（Clerk），而消费者（Customer）从店员处取走产品， * 店员一次只能持有固定数量的产品（比如：20），如果生产者试图生产更多的产品，店员 * 会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品 * 了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
多线程 - 生产者消费者问题
weixin_30652879的博客
03-20 266
（一）生产者消费者问题： 　　1.题目： 　　　　采用Java 多线程技术，设计实现一个符合生产者和消费者问题的程序。 对一个对象（枪膛）进行操作，其最大容量是10颗子弹。 生产者线程是一个压入线程，它不断向枪膛中压入子弹；消费者线程是一个射出线程，它不断从枪膛中射出子弹。 　　2.分析： 　　　　这是个生产者与消费者问题，也是线程的同步问题， 为了防止执行个线程访问一个资源时出现忙等待，...
玩转java多线程 之多线程基础 生产者消费者问题 以及 解决此类问题的方法
weixin_45806131的博客
10-10 557
有两个线程，一个生产线程，一个消费线程 应用场景： 假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者取走消费 假设没有商品，生产者将产品放入仓库，否则停止生产并等待，直到仓库中产品被消费者取走为止 如果有产品，消费者取走消费，否则停止消费等待，直到仓库中有产品为止 ...
生产者消费者问题2 ---- 经典同步互斥 （3个文件，涉及共享内存，每个消费者只能拿一次，如果一次没拿到全部想要的，没有第二次机会拿）
sumisu666的博客
04-26 476
生产者消费者问题，三个.c文件实现 procon.c producer.c consumer.c 通过procon.c来控制producer.c和consumer.c的运行。 下图是我整个文件里面的文件，方便大家更能理解。 //procon.c #include <stdio.h> #include <stdlib.h> #include <st...
用多线程同步方法解决生产者－消费者问题
03-07
生产者-消费者问题是这种并发模型的一个经典案例，它涉及到如何在多个线程间共享资源，确保数据的一致性和正确性。在这个场景中，生产者线程负责生成数据并放入一个有限的缓冲区，而消费者线程则负责从缓冲区取出...
并发控制-生产者-消费者问题实验报告
01-17
1. **经典问题的实际应用**：通过在Windows 2K/XP环境下对经典的生产者-消费者问题进行编程实现，帮助学习者理解和掌握实际开发中的并发控制技术。 2. **深入理解同步机制**：实验旨在加深对信号量及`wait`、`...
操作系统课程设计(生产者-消费者,存储管理,虚拟存储器
01-15
1.掌握基本的同步互斥算法，理解生产者和消费者模型。 2.了解Windows 2000/XP中多线程的并发执行机制，线程间的同步和互斥。 3.学习使用Windows 2000/XP中基本的同步对象，掌握相应的API。 三、实验要求 1.生产者...
操作系统课程设计生产者和消费者问题源代码
07-05
②从上边的测试数据文件例子可以看出，某一生产者生产一个产品后，可能不止一个消费者，或者一个消费者多次地请求消费该产品。此时，只有当所有的消费需求都被满足以后，该产品所在的共享缓冲区才可以被释放，并...
windows下多线程（生产者消费者问题：3个生产者，一个消费者，4个缓冲区）
vontear的专栏
12-02 4246
原作者提供源码为两种情况： 第一种：1生产者1消费者1缓冲区 第二种：1生产者 2消费者 4缓冲区 ========================下面为修改作者源码得到的 3个生产者1个消费者4个缓冲区的情况==================  //1生产者 2消费者 4缓冲区 #include #include #include //设置控制台输出颜
以生产者消费者为例实现Linux进程线程控制
静-静的雪
08-21 3653
操作系统课程设计实验报告 设计题目一：Linux进程线程控制 ——以生产者消费者为例实现进程线程控制 ——by  一、设计题目要求 加深理解进程和程序、进程和线程之间的联系与区别； 深入理解进程及线程的重要数据结构及实现机制； 熟悉进程及线程的创建、执行、阻塞、唤醒、终止等控制方法； 学会使用进程及线程开发应用程序。 二、程序设计思路及流程图 程序功能简介： 生产者功能描述：
生产者消费者问题(多进程+共享内存+信号量)
carlosli的专栏
03-20 2586
最近学习java多线程，遇到生产者，消费者问题。记录一下，加以巩固 生产者和消费者问题是多个相互合作的进程之间的一种抽象。生产者和消费者之间的关系: 1.  对缓冲区的访问是互斥的。由于两者都会修改缓冲区，因此，一方修改缓冲区时，另一方不能修改，这就是互斥。 2.  一方的行为影响另一方。缓冲区不空，才能消费，何时不空？生产了就不空；缓冲区满，就不能生产，何时不满？消费了
实验三、生产者消费者问题（Linux）
weixin_42585296的博客
12-16 4583
问题描述 实验三、生产者消费者问题（20分） 1、在Windows和Linux系统下通过进程编程模拟生产者消费者算法 2、设计一个大小为4的缓冲区，初始为"-”，表示空 3、创建3个生产者，每个生产者 -随机等待一段3秒以内(含3秒)的时间，向缓冲区随机添加一个姓名首字母(大写)，如王全玉的首字母为W、Q、Y，即每次从这三个字母中取一个； -若缓冲区已满，等待消费者取走字母后再添加； -重复4次；...
Linux 生产者和消费者问题
nuptxiaoli
08-08 631
1.多个线程操作临界区要使用线程锁 2.进入临界区后等待某个条件才能继续执行，该线程一直霸占着锁，所以需要该线程主动放弃这个锁，并等待条件达到被唤醒。故出现了  pthread_cond_wait(&g_cond,&g_mutex); 3.pthread_cond_wait(&g_cond,&g_mutex);背后隐藏的事情 拿到锁的线程，把锁暂时丢掉（因为该函数中传入了g_mut
【Linux】生产者和消费者问题
Scenlyf的博客
08-03 1654
aaaa
经典同步问题 5个生产者和5个消费者共享3个缓冲区问题（C++实现）
幽香飞狐的博客
10-20 4856
    #include &lt;iostream&gt;  #include &lt;stdlib.h&gt;  #include &lt;STDIO.H&gt;  #include &lt;windows.h&gt;  using namespace std;  typedef int semaphore;                          /* 信号量是一...
c语言if的作用,C语言问题 这里的if(j==i)有什么作用，意义何在？
weixin_33724428的博客
05-16 607
C语言问题 这里的if(j==i)有什么作用，意义何在？以下文字资料是由(历史新知网www.lishixinzhi.com)小编为大家搜集整理后发布的内容，让我们赶快一起来看一下吧！C语言问题 这里的if(j==i)有什么作用，意义何在？for(j=2;j这里的save()代表什么，c语言问题。是个save()函式，应该前面有写，是自己定义的函式，不是系统里自带的static在这里的作用 c语言s...
Windows环境下的生产者-消费者模型：基于API的多线程同步实验
"这篇文档是关于操作系统实验报告，主要探讨了生产者-消费者模型在Windows环境下的实现，涉及多线程、同步互斥以及信号量机制。报告详细介绍了实验目的、任务、要求、设计思路，并提供了相关的API函数和头文件说明。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值