消费者生产者实验

最新推荐文章于 2022-10-24 23:42:24 发布
最新推荐文章于 2022-10-24 23:42:24 发布
阅读量707 收藏 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 3787
进程是指一个具有一定独立功能的程序在一个数据集合上的一次动态执行过程。同时，进程也是系统分配资源的最小单位。资源 ：内存、网络、硬盘cpu : 多核cpu，把多个cpu打包捆绑在一起，安装在电脑，每个cpu核心都可以执行进程的代码信号量机制是一种功能较强的机制，可用于解决互斥和同步的问题，它只能被两个标准的原语wait(S)和signal(S)访问，也可以记为“P操作”和“V操作”。原语：指完成某种功能且不被分割，不被中断执行的操作序列，通常可由硬件来实现。例如TestAndSet和Swap指令就是通过硬件
模拟消费者生产者实验
01-08
总结来说，"模拟消费者生产者实验"是一个演示操作系统并发控制概念的实践项目，它利用Java的并发工具来实现生产者和消费者之间的线程同步。这个实验不仅有助于理解多线程编程，而且对于设计高效、安全的并发应用程序...
进程模拟生产者-消费者问题
coderlyf的博客
12-04 2726
模拟经典进程调度问题生产者与消费者
模拟生产者/消费者模型
creat_ok的专栏
08-15 854
/* ** 模拟生产者/消费者模型 ** 模拟过程： ** 生产者 消费者 ** ** P(上限控制旗语) P(下限控制旗语) ** P(仓库互斥访问旗语) ** 添加产品 消费产品 ** V(仓库互斥访问旗语) ** V(下限控制旗语) V(上限控制旗语) ** */ #include #include //类型 #include //信号量
实验3：生产者消费者问题实践（编程实验）
qq_62791684的博客
10-24 6841
生产者消费者问题实践（编程实验）
操作系统实验二总结（生产者消费者问题）
热门推荐
小王同学的博客
05-13 1万+
为了这个实验二，资料查了巨多，pv操作什么的好不容易弄明白了，但是感觉老师要求的好像用不到这个。 大部分都是某位同学的成果哈哈哈。 自己总结了一下： 1.队列和链表在c++中是可以直接用已经有的模板的。 2.学会用指针进行遍历。 3.消费者要是能放到buffer里就看生产者等待队列里有没有人，有人就唤醒一个生产者。 4.要是buffer只有1那么大，最终完成链表中必定是生产者和消费者交...
作业必备：操作系统实验七【生产者消费者实验（二）：共享存储区的同步互斥】
qq_52300499的博客
07-13 1914
目录🌝🌝🌝前言：🍀🍀 【实验资料】 🍀🍀🍀一、什么是共享存储区🤓🤓🤓？ 二、 相关系统调用👀👀🌻🌻1、shmget( )：创建、获得一个共享存储区。🌻🌻2、shmat( ) ：用来将共享内存映射到进程的虚拟地址空间。🌻🌻3、shmdt( )：把一个共享存储区从指定进程的虚地址空间断开。🌻🌻4、shmctl( )：共享存储区的控制，对其状态信息进行读取和修改。正文：🍀🍀【实验目的】：🍀🍀🍀【实验内容】：🍀🍀🍀🌸🌸🌸一、编写程序，实现多进程对共享存......
“生产者-消费者”实验
Longerandlonger的专栏
05-31 1478
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 3640
生产者-消费者(producer-consumer)问题是一个著名的进程同步问题。它描述的是:有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。为使生产者进程与消费者进程能并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将其所生产的产品放入一个缓冲区中;消费费者进程可从一个缓冲区中取走产品去消费。尽管所有的生产者进程和消费者进程都是以异步方式运行的，但它们之间必须保持同步，既不允许消费者进程到一个空缓冲区去取产品，也不允许生产者进程向一个已装满产品且尚未被取走.........
生产者消费者模拟程序
tanyujing的专栏
03-31 1754
//模拟生产者消费者，生产者(Producter类)生产窝头(WoTou类)，放入一个大筐(stack类)，消费者（Consumer类）从大筐中取出窝头并打印窝头的id public class producconsumertest { /** * @param args */ public static void main(String[] args) { Stack ss =
生产者与消费者实验报告
10-30
生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告生产者与消费者实验报告
多线程实验（生产者消费者）
11-23
十分适合初学多线程的人.生产者消费者问题，有2个阻塞，生产者阻塞和消费者阻塞。
生产者消费者问题实验报告和代码实现
01-07
1、通过编写程序，掌握基本的同步互斥算法，理解生产者和消费者模型。 2、了解多线程并发执行机制，线程间的同步和互斥。 3、学习使用同步对象，掌握相应的函数。
生产者-消费者问题的模拟实现（课设含源代码）.doc
03-03
用进程同步方法解决“生产者-消费者”问题，C或C++语言实现。 1、设计目的 通过研究进程并发和信号量机制，实现生产者-消费者问题的并发控制。 2、设计要求 1）每个生产者和消费者对有界缓冲区进行操作后，即时显示有界缓冲区的全部内容，当前指针位置和生产者/消费者进程的标识符。 说明：有界缓冲区（提示：有界缓冲区可用数组实现）内设有20个存储单元，放入/取出的数据项设定为1-20这20个整型数。 2）生产者和消费者各有两个以上。 3）多个生产者或多个消费者之间须有共享对缓冲区进行操作的函数代码。
生产者消费者实验报告.doc
06-27
实验报告涉及的是操作系统中的经典问题——生产者-消费者问题，这是一个多线程并发控制的经典案例。在这个实验中，主要目标是通过Java编程实现基于信号量机制的进程（线程）同步和互斥，以模拟生产者和消费者如何...
四川大学操作系统课程设计高分报告-第三次实验-生产者和消费者问题.doc
08-18
实验报告的标题揭示了本次操作系统课程设计的主题——“生产者和消费者问题”，这是一个经典的问题，常见于多线程编程和并发控制的学习中。该问题旨在模拟一个系统，其中多个生产者线程生产产品，而多个消费者线程...
生产者消费者架构的串口高速数据采集.rar_greatervgw_labview_串口_串口 消费者_生产者消费者
07-13
在IT领域，生产者消费者架构是一种常见的多线程或并发编程模型，用于高效地处理数据流。这个模型基于消息队列的概念，适用于各种环境，包括LabVIEW（Laboratory Virtual Instrument Engineering Workbench）这样的...
操作系统实验报告经典的生产者—消费者问题.pdf
最新发布
05-24
"操作系统实验报告经典的生产者—消费者问题" 本实验报告的目的是实现对经典的生产者—消费者问题的模拟，以便更好的理解经典进程同步问题。生产者—消费者问题是典型的PV操作问题，假设系统中有一个比拟大的缓冲池...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值