消费者生产者实验

最新推荐文章于 2023-05-06 17:24:49 发布
最新推荐文章于 2023-05-06 17:24:49 发布
阅读量694 收藏 3
点赞数
分类专栏： 操作系统 文章标签： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45797783/article/details/122266184
版权

生产者与消费者问题

实验目的：

了解和熟悉linux系统下的信号量集和共享内存。

实验任务：

使用linux系统提供的信号量集和共享内存实现生产者和消费者问题。

实验要求：

  1. 写两个程序，一个模拟生产者过程，一个模拟消费者过程；
  2. 创建一个共享内存模拟生产者-消费者问题中缓冲队列，该缓冲队列有N（例如N=10）个缓冲区，每个缓冲区的大小为1024B，每个生产者和消费者对缓冲区必须互斥访问；
  3. 由第一个生产者创建信号量集和共享内存，其他生产者和消费者可以使用该信号量集和共享内存；
  4. 生产者程序：生产者生产产品（即是从键盘输入长度小于1024B的字符）放入空的缓冲区；
  5. 消费者程序：消费者消费产品（即从满的缓冲区中取出内容在屏幕上打印出来），然后满的缓冲区变为空的缓冲区；
  6. 多次运行生产者程序和消费者进程，可以产生多个生产者进程和多个消费者进程，这些进程可以共享这些信号量和共享内存，实现生产者和消费者问题；
  7. 在生产者程序程序中，可以选择：
    1. 生产产品；
    2. 退出。退出进程，但信号量和共享内存仍然存在，其他生产者进程和消费者进程还可以继续使用；
    3. 删除信号量和共享内存。显性删除信号量和共享内存，其他生产者进程和消费者进程都不能使用这些信号量和共享内存。
  8. 在消费者程序中，可以选择：
  1. 消费产品；
  2. 退出。退出进程，但信号量和共享内存仍然存在，其他生产者进程和消费者进程还可以继续使用；
  3. 删除信号量和共享内存。显性删除信号量和共享内存，其他生产者进程和消费者进程都不能使用这些信号量和共享内存。

实验代码：

生产者代码：

#include<unistd.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<sys/types.h>

#include<sys/sem.h>

#include<sys/shm.h>

#define N 4

#define size  N*1024+8

union semun{

    int val;

    struct semid_ds *buf;

    unsigned short *array;

};    //信号量集 

int main(){

    //记录缓冲区开始的位置和结束的位置

    int* start;

    int* end;

       /*****申请共享内存空间*****/ 

    int shmid;

    char *viraddr;

    char buffer[1024];

    shmid=shmget(8888,size,0666|IPC_CREAT);

    viraddr=(char*)shmat(shmid,0,0);

    start = (int*)viraddr;//缓冲区开始有的位置 

    end = (int*)(viraddr+4);//缓冲区开始结束的位置 

    /*****定义PV操作*****/

    struct sembuf P,V;

    P.sem_num=0;

    P.sem_op=-1;

    P.sem_flg=SEM_UNDO;

    V.sem_num=0;

    V.sem_op=1;

    V.sem_flg=SEM_UNDO;

    /*****申请只有一个信号量的信号量集*****/

    int emptyid;

    int fullid;                                 //同步信号量

    int mutex;  //互斥信号量

 union semun arg;                                 

    if(semget(1000,1,IPC_CREAT|IPC_EXCL)!= -1){

    

        emptyid=semget(1000,1,IPC_CREAT|0666);

     fullid=semget(2000,1,IPC_CREAT|0666);

      mutex=semget(3000,1,IPC_CREAT|0666);\

            /*****分别对每个信号量赋初值*****/

       

        arg.val=N;

        semctl(emptyid,0,SETVAL,arg);

        arg.val=0;

        semctl(fullid,0,SETVAL,arg);

        arg.val=1;

        semctl(mutex,0,SETVAL,arg);

        *end = *start=0;

        puts("第一个生产者初始化\n");

    }else{

        printf("这不是第一个生产者\n");

        emptyid=semget(1000,1,0666);

        fullid=semget(2000,1,0666);

        mutex=semget(3000,1,0666);

    }

    

    int flag =0;

while(1){

    puts("1 生产产品，2 退出，3 撤销信号量集、释放共享内存");

    scanf("%d",&flag);

    getchar();

    switch(flag){

        case 1:

            start = (int*)viraddr;//缓冲区开始有的位置 

            end = (int*)(viraddr+4);//缓冲区开始结束的位置 

            char* p = viraddr+8+(*end)*1024;//共享内存正文开始位置

            semop(emptyid,&P,1);

            semop(mutex,&P,1);

            puts("输入生产的信息：");

            fgets(buffer,1024,stdin);

            strcpy(p,buffer);

            *end = (*end+1)%N;

            semop(mutex,&V,1);

            semop(fullid,&V,1);

            printf("生产成功 start=%d  end=%d\n",*start,*end);

            break;

        case 2:

            printf("退出成功\n");

            exit(0);

            break;

        case 3:

            shmdt(viraddr);

            /*****撤销信号量集、释放共享内存*****/

            shmctl(shmid,IPC_RMID,0);

            semctl(emptyid,IPC_RMID,0);

            semctl(fullid,IPC_RMID,0);

            semctl(mutex,IPC_RMID,0);

            printf("撤销成功，退出\n");

            exit(0);

            break;      

    }       

}

    return 0;

} 

消费者代码：

#include<unistd.h>

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

#include<sys/types.h>

#include<sys/sem.h>

#include<sys/shm.h>

#define N 4

#define size  N*1024+8

int main(){

    

    //记录缓冲区开始的位置和结束的位置

    int* start;

    int* end; 

        /*****申请只有一个信号量的信号量集*****/

    int emptyid;

    int fullid;                                 //同步信号量

    int mutex;                                  //互斥信号量 

    emptyid=semget(1000,1,0666);

    fullid=semget(2000,1,0666);

    mutex=semget(3000,1,0666);

    /*****定义PV操作*****/

    struct sembuf P,V;

    P.sem_num=0;

    P.sem_op=-1;

    P.sem_flg=SEM_UNDO;

    V.sem_num=0;

    V.sem_op=1;

    V.sem_flg=SEM_UNDO;

    /*****申请共享内存空间*****/ 

    int shmid;

    char *viraddr;

    char buffer[1024];

    shmid=shmget(8888,size,0666|IPC_CREAT);

    viraddr=(char*)shmat(shmid,0,0);

    

    int flag =0;

while(1){

    puts("1 消费产品，2 退出，3 撤销信号量集、释放共享内存");

    scanf("%d",&flag);

    getchar();

    switch(flag){

        case 1:

            start = (int*)viraddr;//缓冲区开始有的位置 

            end = (int*)(viraddr+4);//缓冲区开始结束的位置 

            char* p = viraddr+8+(*start)*1024;

            //    消费代码段 

                semop(fullid,&P,1);

            semop(mutex,&P,1);

            printf("消费的消息是: %s",p);

            *start = (*start+1)%N;

            printf(" start=%d ",*start);

            printf(" end=%d \n",*end);

            semop(mutex,&V,1);

            semop(emptyid,&V,1);

            break;

        case 2:

            printf("退出成功\n");

            exit(0);

            break;

        case 3:

        shmdt(viraddr);

            /*****撤销信号量集、释放共享内存*****/

            shmctl(shmid,IPC_RMID,0);

            semctl(emptyid,IPC_RMID,0);

            semctl(fullid,IPC_RMID,0);

            semctl(mutex,IPC_RMID,0);

            printf("撤销成功，退出\n");

            exit(0);

            break;      

    }       

}

}

运行结果：

第一个生产者：

第二个生产者：

消费者：

实验总结：

实验分析：实验的核心是信号量和共享内存的使用，功能选择是比较简单的switch case 语句。

信号量：实验一共使用了三个信号量，其中emptyid和fullid，用于进程同步，mutex用于进程互斥，使用时先P(emptyid/fullid)再P(mutex)可以预防死锁。

判断是不是第一个生产者通过semget(1000,1,IPC_CREAT|IPC_EXCL)!= -1来判断，满足条件则对共享变量和信号量进行创建。

start

end

p

共享内存：共享内存按这个格式设置：

其中start用于指明缓冲区开始有的位置，end用于指明缓冲区结束的位置，p是共享内存开始的位置；所以共享内存的大小是4*2+1024*N，N个缓冲区。

实验中所有的key（用来指明共享内存或者信号量的）为了不同进程使用的是同一个，全部设置为常数。

遇到的问题：

1. 开始没想到怎么判断是不是第一个生产者，解决办法是通过semget(1000,1,IPC_CREAT|IPC_EXCL)!= -1来设置。

2. 实验中的key如果设置为IPC_PRIVATE，不同的进程间好像是不一样的，解决办法是设置为常数。

生产者代码：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/sem.h>
#include<sys/shm.h>
#define N 4
#define size  N*1024+8

union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};    //信号量集 

int main(){
	//记录缓冲区开始的位置和结束的位置
	int* start;
	int* end;
	   /*****申请共享内存空间*****/ 
    int shmid;
    char *viraddr;
    char buffer[1024];
    shmid=shmget(8888,size,0666|IPC_CREAT);
    viraddr=(char*)shmat(shmid,0,0);
    start = (int*)viraddr;//缓冲区开始有的位置 
    end = (int*)(viraddr+4);//缓冲区开始结束的位置 

	/*****定义PV操作*****/
	struct sembuf P,V;
    P.sem_num=0;
    P.sem_op=-1;
    P.sem_flg=SEM_UNDO;
    V.sem_num=0;
    V.sem_op=1;
    V.sem_flg=SEM_UNDO;
    /*****申请只有一个信号量的信号量集*****/
    int emptyid;
	int fullid;                                 //同步信号量
    int mutex;  //互斥信号量

 union semun arg;                                 
    if(semget(1000,1,IPC_CREAT|IPC_EXCL)!= -1){
	
    	emptyid=semget(1000,1,IPC_CREAT|0666);
   	 fullid=semget(2000,1,IPC_CREAT|0666);
  	  mutex=semget(3000,1,IPC_CREAT|0666);\
  	  	    /*****分别对每个信号量赋初值*****/
	   
	    arg.val=N;
	    semctl(emptyid,0,SETVAL,arg);
	    arg.val=0;
 	   	semctl(fullid,0,SETVAL,arg);
  	  	arg.val=1;
   		semctl(mutex,0,SETVAL,arg);
   		*end = *start=0;
   		puts("第一个生产者初始化\n");
	}else{
		printf("这不是第一个生产者\n");
		emptyid=semget(1000,1,0666);
   	 	fullid=semget(2000,1,0666);
  	  	mutex=semget(3000,1,0666);
	}
    

	int flag =0;
while(1){
	puts("1 生产产品，2 退出，3 撤销信号量集、释放共享内存");
	scanf("%d",&flag);
	getchar();
	switch(flag){
		case 1:
			start = (int*)viraddr;//缓冲区开始有的位置 
		    end = (int*)(viraddr+4);//缓冲区开始结束的位置 
			char* p = viraddr+8+(*end)*1024;//共享内存正文开始位置
			semop(emptyid,&P,1);
			semop(mutex,&P,1);

			puts("输入生产的信息：");
			fgets(buffer,1024,stdin);
			strcpy(p,buffer);
			*end = (*end+1)%N;
			semop(mutex,&V,1);
			semop(fullid,&V,1);
			printf("生产成功 start=%d  end=%d\n",*start,*end);
			break;
		case 2:
			printf("退出成功\n");
			exit(0);
			break;
		case 3:
			shmdt(viraddr);
	        /*****撤销信号量集、释放共享内存*****/
	        shmctl(shmid,IPC_RMID,0);
	        semctl(emptyid,IPC_RMID,0);
	        semctl(fullid,IPC_RMID,0);
	        semctl(mutex,IPC_RMID,0);
	        printf("撤销成功，退出\n");
	        exit(0);
			break;		
	} 		
}
	return 0;
}

消费者代码：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<sys/sem.h>
#include<sys/shm.h>
#define N 4
#define size  N*1024+8


int main(){
	
	//记录缓冲区开始的位置和结束的位置
	int* start;
	int* end; 
		/*****申请只有一个信号量的信号量集*****/
    int emptyid;
	int fullid;                                 //同步信号量
    int mutex;                                  //互斥信号量 
	emptyid=semget(1000,1,0666);
   	fullid=semget(2000,1,0666);
  	mutex=semget(3000,1,0666);
	/*****定义PV操作*****/
	struct sembuf P,V;
    P.sem_num=0;
    P.sem_op=-1;
    P.sem_flg=SEM_UNDO;
    V.sem_num=0;
    V.sem_op=1;
    V.sem_flg=SEM_UNDO;

    /*****申请共享内存空间*****/ 
    int shmid;
    char *viraddr;
    char buffer[1024];
    shmid=shmget(8888,size,0666|IPC_CREAT);
    viraddr=(char*)shmat(shmid,0,0);
    
    int flag =0;
while(1){
	puts("1 消费产品，2 退出，3 撤销信号量集、释放共享内存");
	scanf("%d",&flag);
	getchar();
	switch(flag){
		case 1:
		    start = (int*)viraddr;//缓冲区开始有的位置 
		    end = (int*)(viraddr+4);//缓冲区开始结束的位置 
		    char* p = viraddr+8+(*start)*1024;
		    //    消费代码段 
		    	semop(fullid,&P,1);
			semop(mutex,&P,1);
			printf("消费的消息是: %s",p);
			*start = (*start+1)%N;
			printf(" start=%d ",*start);
			printf(" end=%d \n",*end);
			semop(mutex,&V,1);
			semop(emptyid,&V,1);
			break;
		case 2:
			printf("退出成功\n");
			exit(0);
			break;
		case 3:
		shmdt(viraddr);
	        /*****撤销信号量集、释放共享内存*****/
	        shmctl(shmid,IPC_RMID,0);
	        semctl(emptyid,IPC_RMID,0);
	        semctl(fullid,IPC_RMID,0);
	        semctl(mutex,IPC_RMID,0);
	        printf("撤销成功，退出\n");
	        exit(0);
			break;		
	} 		
}


}

昵称读取失败
关注
专栏目录
操作系统实验报告：生产者――消费者问题算法的实现
m0_59757577的博客
06-06 3688
进程是指一个具有一定独立功能的程序在一个数据集合上的一次动态执行过程。同时，进程也是系统分配资源的最小单位。资源 ：内存、网络、硬盘cpu : 多核cpu，把多个cpu打包捆绑在一起，安装在电脑，每个cpu核心都可以执行进程的代码信号量机制是一种功能较强的机制，可用于解决互斥和同步的问题，它只能被两个标准的原语wait(S)和signal(S)访问，也可以记为“P操作”和“V操作”。原语：指完成某种功能且不被分割，不被中断执行的操作序列，通常可由硬件来实现。例如TestAndSet和Swap指令就是通过硬件
作业必备：操作系统实验七【生产者消费者实验（二）：共享存储区的同步互斥】
qq_52300499的博客
07-13 1822
目录🌝🌝🌝前言：🍀🍀 【实验资料】 🍀🍀🍀一、什么是共享存储区🤓🤓🤓？ 二、 相关系统调用👀👀🌻🌻1、shmget( )：创建、获得一个共享存储区。🌻🌻2、shmat( ) ：用来将共享内存映射到进程的虚拟地址空间。🌻🌻3、shmdt( )：把一个共享存储区从指定进程的虚地址空间断开。🌻🌻4、shmctl( )：共享存储区的控制，对其状态信息进行读取和修改。正文：🍀🍀【实验目的】：🍀🍀🍀【实验内容】：🍀🍀🍀🌸🌸🌸一、编写程序，实现多进程对共享存......
“生产者-消费者”实验
Longerandlonger的专栏
05-31 1471
package thread; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public class WaitTest { /** * 容器的最大长度 */ private static final int listSize = 3;
实验报告 生产者――消费者问题算法的实现（cpp)
nicebrother的博客
06-03 3378
生产者-消费者(producer-consumer)问题是一个著名的进程同步问题。它描述的是:有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。为使生产者进程与消费者进程能并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将其所生产的产品放入一个缓冲区中;消费费者进程可从一个缓冲区中取走产品去消费。尽管所有的生产者进程和消费者进程都是以异步方式运行的，但它们之间必须保持同步，既不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品且尚未被取走.........
生产者消费者模拟程序
tanyujing的专栏
03-31 1740
//模拟生产者消费者，生产者(Producter类)生产窝头(WoTou类)，放入一个大筐(stack类)，消费者（Consumer类）从大筐中取出窝头并打印窝头的id public class producconsumertest { /** * @param args */ public static void main(String[] args) { Stack ss =
模拟消费者生产者实验
01-08
总结来说，"模拟消费者生产者实验"是一个演示操作系统并发控制概念的实践项目，它利用Java的并发工具来实现生产者和消费者之间的线程同步。这个实验不仅有助于理解多线程编程，而且对于设计高效、安全的并发应用程序...
生产者消费者实验报告.doc
06-27
实验报告涉及的是操作系统中的经典问题——生产者-消费者问题，这是一个多线程并发控制的经典案例。在这个实验中，主要目标是通过Java编程实现基于信号量机制的进程（线程）同步和互斥，以模拟生产者和消费者如何...
四川大学操作系统课程设计高分报告-第三次实验-生产者和消费者问题.doc
08-18
实验报告的标题揭示了本次操作系统课程设计的主题——“生产者和消费者问题”，这是一个经典的问题，常见于多线程编程和并发控制的学习中。该问题旨在模拟一个系统，其中多个生产者线程生产产品，而多个消费者线程...
OS大作业生产者消费者同步问题的实现
07-16
在操作系统中，生产者-消费者问题是多线程和并发编程中的一个经典问题，它涉及到资源的共享和同步。本大作业旨在让学生理解并熟练运用POSIX提供的同步机制，特别是互斥锁和条件变量，来解决这个问题。以下是相关知识...
生产者消费者架构的串口高速数据采集.rar_greatervgw_labview_串口_串口 消费者_生产者消费者
07-13
在IT领域，生产者消费者架构是一种常见的多线程或并发编程模型，用于高效地处理数据流。这个模型基于消息队列的概念，适用于各种环境，包括LabVIEW（Laboratory Virtual Instrument Engineering Workbench）这样的...
生产者与消费者实验报告
10-30
生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告
多线程实验（生产者消费者）
11-23
十分适合初学多线程的人.生产者消费者问题，有2个阻塞，生产者阻塞和消费者阻塞。
生产者消费者问题实验报告和代码实现
01-07
1、通过编写程序，掌握基本的同步互斥算法，理解生产者和消费者模型。 2、了解多线程并发执行机制，线程间的同步和互斥。 3、学习使用同步对象，掌握相应的函数。
生产者-消费者问题的模拟实现（课设含源代码）.doc
03-03
用进程同步方法解决“生产者-消费者”问题，C或C++语言实现。 1、设计目的 通过研究进程并发和信号量机制，实现生产者-消费者问题的并发控制。 2、设计要求 1）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容，当前指针位置和生产者/消费者进程的标识符。 说明：有界缓冲区（提示：有界缓冲区可用数组实现）内设有20个存储单元，放入/取出的数据项设定为1-20这20个整型数。 2）生产者和消费者各有两个以上。 3）多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。
生产者消费者问题（共享内存实现）
IT呵呵哒的博客
04-30 4946
问题描述：    生产者-消费者问题，也称作有界缓冲区问题，两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行阻塞，等待消费者从缓冲区中取走了一个或者多个数据后再去唤醒它。同样地，当缓冲区已经空了，而消费者还想去取消息，此时...
【设计模式】C语言使用共享内存和信号量，完美实现生产者与消费者模式
最新发布
Michael
05-06 1138
这种模式的优点是可以实现生产者和消费者之间的解耦，使得它们可以独立地进行操作，从而提高了系统的并发性和可扩展性。在生产者进程中，当共享内存非满时，生产者将 item 放入共享内存，并增加 full 信号量的值；在消费者进程中，当共享内存非空时，消费者从共享内存中取出一个项目，并增加 empty 信号量的值。由于信号量的特性，当信号量的值为 0 时，调用。总之，只要存在生产者和消费者之间的数据交换，就可以考虑使用生产者和消费者模式来实现。在该示例中，我们使用了共享内存和信号量来实现生产者和消费者模式。
《操作系统》生产者消费者同步问题的算法实现
yubo_830的博客
12-01 4992
《操作系统》课程实验（一） ——生产者消费者同步问题的算法实现 实验目的 全面理解生产者与消费者问题模型，掌握解决该问题的算法思想，正确使用同步机制。 实验内容 问题描述：一组生产者向一组消费者提供消息，它们共享一个有界缓冲池，生产者向其中投放消息，消费者从中取得消息。假定这些生产者和消费者互相等效，只要缓冲池未满，生产者可将消息送入缓冲池；只要缓冲池未空，消费者可从缓冲池取走一个消息。...
Linux生产者消费者实验目的,多线程编程之：实验内容——“生产者消费者”实验...
weixin_39977488的博客
05-15 337
9.3实验内容——“生产者消费者”实验1．实验目的“生产者消费者”问题是一个著名的同时性编程问题的集合。通过学习经典的“生产者消费者”问题的实验，读者可以进一步熟悉Linux中的多线程编程，并且掌握用信号量处理线程间的同步和互斥问题。2．实验内容“生产者—消费者”问题描述如下。有一个有限缓冲区和两个线程：生产者和消费者。他们分别不停地把产品放入缓冲区和从缓冲区中拿走产品。一个生产者在缓冲区满的时候...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值