devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

（C语言）多进程实现消费者生产者pv操作，Windows和LInux版本_c实现多生产者消费者问题

作者：2023面试高手 | 2024-03-19 14:23:43

赞

踩

c实现多生产者消费者问题

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

一，实验目的

1，了解生产者消费者的互斥与同步问题

2，掌握Windows和Linux的进程通信方法

二，实验要求

完成Windows版本和Linux版本。

一个大小为3的缓冲区，初始为空。

2个生产者

    • 随机等待一段时间，往缓冲区添加数据，
    • 若缓冲区已满，等待消费者取走数据后再添加
    • 重复6次

3个消费者

    • 随机等待一段时间，从缓冲区读取数据
    • 若缓冲区为空，等待生产者添加数据后再读取
    • 重复4次

显示每次添加和读取数据的时间及缓冲区的状态

三，实验环境

Windows版本：Windows 10 64位系统，Dev-cpp编译器

Linux版本：Fedora29版本，gcc环境 vim文本编辑器

四，实验代码结构

1),pv操作伪代码：

array[3]:interger//缓冲区定义,大小为三

int empty=3,full=0;

int mutex=1;

i=0,j=0//缓冲区指针

x，y：item //产品变量

生产者：                                                                                              消费者：

begin：

produce a product to x;

P(empty);

P(mutex);

array[i]=x;

ii=(i+1)%3;

V(full);

V(mutex);

,,,,,, .........,

End

消费者：

end

 

 

2）实验代码分析

Windows版本：

思路分析：Windows创建多进程使用creatprocess()函数调用自己，通过多次创建得到两个生产者进程三个消费者进程，在之中运行相应的生产者函数，消费者函数。在通过传入参数不同，来辨别是第一次主进程还是生产者进程，消费者进程。通过构建共享内存区进行进程间通信。

①多进程创建

 

② 构建共享内存区，再将文件映射到本进程，初始化

③在主创建进程间信号量full empty

分别在生产者消费者进程创建互斥访问量mutex

④同过argv量的不同判断进程归属

 

⑤

运行结果：

全部代码见后

Linux版本：

思路分析：Linux使用fork进行多进程创建，分别在进程中运行消费者函数，生产者函数。建立共享主存区很信号量在进程建进行通信和缓存访问

①，创建进程分别运行消费者和生产者函数

②建立共享主存并进行映射

③创建进程间信号量full，empty和互斥量 mutex，并初始化

 

④实验结果：

五， 实验总结

本次实验获得圆满成功。

本次实验通过分别编写Windows和Linux版本的多进程实现消费者和生产者问题，了解生产者消费者的互斥与同步问题，掌握Windows和Linux的进程通信方法，也同时加强自己对多进程操作的理解。

代码：

  1. WIndows版本：
  2. //实验三生产者消费者 
  3. #include <windows.h>
  4. #include <stdio.h>
  5. #include <time.h>
  6.  
  7.  
  8. HANDLE handleOfProcess[5];
  9.  
  10. struct buf  
  11. {  
  12. 	char buffer[3];
  13. 	int write;
  14. 	int read;
  15. };  
  16.  
  17. int rand_1()
  18. {
  19.   return rand()%100+1000;
  20. }
  21.  
  22. char rand_char()
  23. {
  24. 	return rand()%26+'A';
  25. }
  26.  
  27. void StartClone(int nCloneID)
  28. {
  29. 	TCHAR szFilename[MAX_PATH];
  30. 	GetModuleFileName(NULL,szFilename,MAX_PATH);
  31.  
  32. 	TCHAR szCmdLine[MAX_PATH];
  33. 	sprintf(szCmdLine,"\"%s\" %d",szFilename,nCloneID);
  34. 	//printf("%s\n",szCmdLine);
  35.  
  36. 	STARTUPINFO si;
  37. 	ZeroMemory(reinterpret_cast<void*>(&si),sizeof(si));
  38.  
  39. 	si.cb=sizeof(si);
  40. 	PROCESS_INFORMATION pi;
  41.  
  42. 	BOOL bCreateOK=CreateProcess(
  43. 		szFilename,
  44. 		szCmdLine,
  45. 		NULL,
  46. 		NULL,
  47. 		FALSE,
  48. 		CREATE_DEFAULT_ERROR_MODE,
  49. 		NULL,
  50. 		NULL,
  51. 		&si,
  52. 		&pi);
  53. 	if(bCreateOK)
  54. 		handleOfProcess[nCloneID]=pi.hProcess;
  55. 	else
  56. 	{
  57. 		printf("Error in create process!\n");
  58. 		exit(0);
  59. 	}
  60. }
  61.  
  62. void pro()//生产者
  63. {
  64.     HANDLE mutex = CreateMutex(NULL,FALSE,"MYMUTEX");  
  65.     HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"MYEMPTY");  
  66.     HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"MYFULL");  
  67.  
  68.     HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"myfilemap");
  69.     LPVOID Data=MapViewOfFile(//文件映射
  70.         hMap,  
  71.         FILE_MAP_ALL_ACCESS,  
  72.         0,  
  73.         0,  
  74.         0);  
  75.     struct buf *pint=reinterpret_cast<struct buf *>(Data);  
  76.  
  77.     for (int i = 0; i < 6; i++)  
  78.     {  
  79.         WaitForSingleObject(empty, INFINITE);          
  80.         //sleep
  81.         srand((unsigned)time(0));  
  82.         int tim=rand_1();
  83.         Sleep(tim);
  84.  
  85.         WaitForSingleObject(mutex, INFINITE);  
  86.  
  87. //code
  88.         pint->buffer[pint->write]=rand_char();
  89.         pint->write=(pint->write+1)%3;
  90.         
  91.        
  92.         ReleaseMutex(mutex);
  93.         ReleaseSemaphore(full,1,NULL);
  94.  
  95. 		SYSTEMTIME syst;
  96. 		time_t t=time(0);
  97. 		GetSystemTime(&syst);
  98.         char tmpBuf[10];
  99.  		strftime(tmpBuf,10,"%H:%M:%S",localtime(&t));
  100.         printf("生产者%d向缓冲区写入数据:\t%c\t%c\t%c\t@%s.%d\n",
  101.         	(int)GetCurrentProcessId(),pint->buffer[0],pint->buffer[1],
  102.         	pint->buffer[2],tmpBuf,syst.wMilliseconds);
  103. 		fflush(stdout);
  104.     }
  105.     UnmapViewOfFile(Data);//解除映射
  106.     Data=NULL;
  107.     CloseHandle(mutex);
  108.     CloseHandle(empty);
  109.     CloseHandle(full);
  110. }
  111.  
  112. void con()//消费者
  113. {
  114.     HANDLE mutex = CreateMutex(NULL,FALSE,"MYMUTEX");  
  115.    	HANDLE empty = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"MYEMPTY");  
  116.     HANDLE full = OpenSemaphore(SEMAPHORE_ALL_ACCESS,FALSE,"MYFULL");  
  117.  
  118.     HANDLE hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,"myfilemap");
  119.     LPVOID Data=MapViewOfFile(//文件映射
  120.         hMap,  
  121.         FILE_MAP_ALL_ACCESS,  
  122.         0,  
  123.         0,  
  124.         0);  
  125.     struct buf *pint=reinterpret_cast<struct buf *>(Data);  
  126.  
  127.     for (int i = 0; i < 4; i++)  
  128.     {  
  129.         WaitForSingleObject(full,INFINITE);
  130.         //sleep
  131.         srand((unsigned)time(0));  
  132.         int tim=rand_1();
  133.         Sleep(tim);
  134.        
  135.         WaitForSingleObject(mutex,INFINITE);  
  136.  
  137.         pint->buffer[pint->read]=' ';
  138.         pint->read=(pint->read+1)%3;
  139.         
  140.         ReleaseMutex(mutex);  
  141.         ReleaseSemaphore(empty,1,NULL); 
  142. //code
  143.  
  144.         time_t t=time(0);
  145.         char tmpBuf[10];
  146.         SYSTEMTIME syst;
  147.         GetSystemTime(&syst);
  148.  		strftime(tmpBuf,10,"%H:%M:%S",localtime(&t));
  149.  
  150.         printf("消费者%d从缓冲区读取数据:\t%c\t%c\t%c\t@%s.%d\n",
  151.         	(int)GetCurrentProcessId(),pint->buffer[0],pint->buffer[1],
  152.         	pint->buffer[2],tmpBuf,syst.wMilliseconds);
  153. 		 fflush(stdout);
  154.          
  155.     }
  156.     UnmapViewOfFile(Data);//解除映射
  157.     Data=NULL;
  158.     CloseHandle(mutex);
  159.     CloseHandle(empty);
  160.     CloseHandle(full);
  161. }
  162.  
  163. int main(int argc,char * argv[])
  164. {
  165. 	int nCloneID=20;
  166. 	if(argc>1)
  167. 	{
  168. 		sscanf(argv[1],"%d",&nCloneID);
  169. 	}
  170.  
  171. 	if(nCloneID<2)//生产者进程
  172. 	{
  173. 		pro();
  174. 	}
  175. 	else if(nCloneID<5)//消费者进程
  176. 	{
  177. 		con();
  178. 	}
  179. 	else//主进程
  180. 	{
  181.         HANDLE hMap=CreateFileMapping(  
  182.             NULL,  
  183.             NULL,  
  184.             PAGE_READWRITE,  
  185.             0,  
  186.             sizeof(struct buf),  
  187.             "myfilemap");  
  188.  
  189.         if (hMap!=INVALID_HANDLE_VALUE)  
  190.         {  
  191.             LPVOID Data=MapViewOfFile(//文件映射
  192.                 hMap,  
  193.                 FILE_MAP_ALL_ACCESS,  
  194.                 0,  
  195.                 0,  
  196.                 0);  
  197.  
  198.             if (Data!=NULL)
  199.             {  
  200.                 ZeroMemory(Data,sizeof(struct buf));  
  201.             }  
  202.             struct buf *pnData=reinterpret_cast<struct buf *>(Data);  
  203.             pnData->read=0;  
  204.             pnData->write=0;  
  205.             memset(pnData->buffer,0,sizeof(pnData->buffer));  
  206.             UnmapViewOfFile(Data);//解除映射
  207.             Data=NULL;
  208.         }
  209.  
  210.         HANDLE empty = CreateSemaphore(NULL,3,3,"MYEMPTY");  
  211.         HANDLE full = CreateSemaphore(NULL,0,3,"MYFULL");  
  212. 		for(int i=0;i<5;i++)//创建子进程
  213. 			StartClone(i);
  214.         WaitForMultipleObjects(5,handleOfProcess,TRUE,INFINITE);
  215.     CloseHandle(empty);
  216.     CloseHandle(full);
  217. 	}
  218. }

Linux版本：

  1. //实验三：生产者消费者                                                                                                                                                                                             
  2. #include<string.h>
  3. #include <sys/time.h>
  4. #include<stdio.h>
  5. #include<sys/types.h>
  6. #include<unistd.h>
  7. #include<stdlib.h>
  8. #include<sys/sem.h>
  9. #include<sys/select.h>
  10. #include<sys/wait.h>
  11. #include<sys/ipc.h>
  12. #include<sys/shm.h>
  13. #include<time.h>
  14. #define SEM_ID1 225
  15. #define SEM_ID2 97
  16. #define SEM_ID3 234
  17. #define SHMKEY 75
  18.  
  19. struct buf{
  20.   char buffer[3];
  21.   int read;
  22.   int write;
  23. };
  24.  
  25. int rand_1()
  26. {
  27.   return rand()%300;
  28. }
  29.  
  30. void sleep_ms(int s)
  31. {
  32.     usleep(s*10000);
  33. }
  34.  
  35. char* cur_time()
  36. {
  37.     time_t timep;
  38.     time(&timep);
  39.     return ctime(&timep);
  40. }
  41. char rand_char()
  42. {
  43.     return rand()%26+'A';
  44. }
  45. void P (int s)//p操作 
  46. {
  47.     struct sembuf sem_op;
  48.     sem_op.sem_num=0;
  49.     sem_op.sem_op=-1;
  50.     sem_op.sem_flg=0;
  51.     semop(s,&sem_op,1);
  52. }
  53. void V(int s)//v操作 
  54. {
  55.     struct sembuf sem_op;
  56.     sem_op.sem_num=0;
  57.     sem_op.sem_op=1;
  58.     sem_op.sem_flg=0;
  59.     semop(s,&sem_op,1);
  60.  
  61. }
  62. void pro()//生产者
  63. {
  64.     int tim,shmid,i=6;
  65.     int sem_mutex,sem_empty,sem_full;
  66.     void * addr;
  67.     struct buf *pint;
  68.     struct sembuf sem_op;
  69.     struct timeval tv;
  70.     sem_mutex=semget(SEM_ID1,1,0600);
  71.     sem_empty=semget(SEM_ID2,1,0600);
  72.     sem_full=semget(SEM_ID3,1,0600);
  73.     shmid=shmget(SHMKEY,sizeof(struct buf),0777);
  74.     addr=shmat(shmid,0,0);
  75.     while(i--)
  76.     {
  77.         gettimeofday(&tv,NULL);
  78.         srand((unsigned)tv.tv_usec);
  79.         tim=rand_1();
  80.         sleep_ms(tim);  
  81.         //P(empty)
  82.         P(sem_empty);
  83.         //P(mutex)
  84.         P(sem_mutex);
  85.  
  86.         pint=(struct buf *)addr;
  87.  
  88.         // pint[semctl(sem_full,0,GETVAL)]=time;
  89.         pint->buffer[pint->write]=rand_char();
  90.         pint->write=(pint->write+1)%3;
  91.  
  92.         printf("当前生产者进程:%d 写入数据:\t%c\t%c\t%c\t@%lds%ldus\n",
  93.             getpid(),pint->buffer[0],pint->buffer[1],
  94.             pint->buffer[2],tv.tv_sec,tv.tv_usec);
  95.  
  96.  
  97.         //V(mutex)
  98.         V(sem_mutex);
  99.         //V(full)
  100.         V(sem_full);                                                                                                                                                                                               
  101.     }
  102.     shmdt(addr);
  103. }
  104. void con()//消费者
  105. {
  106.     int tim,shmid,i=4;                                                                                                                                                                                             
  107.     int sem_mutex,sem_empty,sem_full;
  108.     void * addr;
  109.     struct buf *pint;
  110.     struct sembuf sem_op;
  111.     struct timeval tv;
  112.     sem_mutex=semget(SEM_ID1,1,0600);
  113.     sem_empty=semget(SEM_ID2,1,0600);
  114.     sem_full=semget(SEM_ID3,1,0600);
  115.     shmid=shmget(SHMKEY,sizeof(struct buf),0777);
  116.     addr=shmat(shmid,0,0);
  117.     while(i--)
  118.     {
  119.         gettimeofday(&tv,NULL);
  120.         srand((unsigned)tv.tv_usec);
  121.         tim=rand_1();
  122.         sleep_ms(tim); 
  123.         //P(full)
  124.         P(sem_full);
  125.         //P(mutex)
  126.         P(sem_mutex);
  127.  
  128.         pint=(struct buf *)addr;
  129.  
  130.         pint->buffer[pint->read]=' ';
  131.         pint->read=(pint->read+1)%3;
  132.  
  133.         printf("当前消费者进程:%d 读取数据:\t%c\t%c\t%c\t@%ldst%ldms\n",
  134.             getpid(),pint->buffer[0],pint->buffer[1],
  135.             pint->buffer[2],tv.tv_sec,tv.tv_usec);
  136.  
  137.         //V(mutex)
  138.         V(sem_mutex);
  139.         //V(empty)
  140.         V(sem_empty);
  141.  
  142.     }
  143.     shmdt(addr);
  144. }
  145.  
  146. int main()
  147. {
  148.     int sem_mutex,sem_empty,sem_full,shmid;
  149.     void * addr; 
  150.     union semun {
  151.       int val;
  152.     }empty,full,mutex;
  153.  
  154. //建立信号量 
  155.     sem_mutex=semget(SEM_ID1,1,IPC_CREAT|0600);
  156.     sem_empty=semget(SEM_ID2,1,IPC_CREAT|0600);
  157.     sem_full=semget(SEM_ID3,1,IPC_CREAT|0600);
  158.  
  159.     full.val=0;
  160.     empty.val=3;
  161.     mutex.val=1;
  162.  
  163.     semctl(sem_mutex,0,SETVAL,mutex);
  164.     semctl(sem_empty,0,SETVAL,empty);
  165.     semctl(sem_full,0,SETVAL,full);
  166.  
  167. //建立共享内存并进行映射 
  168.     shmid=shmget(SHMKEY,sizeof(struct buf),0777|IPC_CREAT);
  169.     if(-1==shmid)
  170.     {
  171.       printf("建立共享内存失败\n");
  172.       exit(0);
  173.     }
  174.     addr=shmat(shmid,0,0);
  175.     memset(addr,0,sizeof(struct buf));
  176.  
  177. //执行生产者进程 
  178.     for(int i=0;i<2;i++)
  179.         if(fork()==0)
  180.         {
  181.             pro();
  182.             exit(0);
  183.         }
  184. //执行消费者进程 
  185.     for(int i=0;i<3;i++)
  186.         if(fork()==0)
  187.         {
  188.             con();
  189.             exit(0);
  190.         }
  191.  
  192.     while(-1 != wait(0));
  193.     semctl(sem_mutex,0,IPC_RMID);
  194.     semctl(sem_empty,0,IPC_RMID);                                                                                                                                                                                  
  195.     semctl(sem_full,0,IPC_RMID);
  196.     shmdt(addr);
  197. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/267924
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号