操作系统实验四——进程同步实验

最新推荐文章于 2024-01-21 10:56:47 发布
最新推荐文章于 2024-01-21 10:56:47 发布
阅读量1.3k 收藏 8
点赞数
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzzzj/article/details/110820037
版权

实验内容：
抽烟者问题。假设⼀个系统中有三个抽烟者进程，每个抽烟者不断地卷烟并抽 烟。抽烟者卷起并抽掉⼀
颗烟需要有三种材料：烟草、纸和胶⽔。⼀个抽烟者有烟草，⼀个有纸，另⼀个有胶⽔。系统中还有两
个供应者进程，它们⽆限地供应所有三种材料，但每次仅轮流提供三种材料中的两种。得到缺失的两种
材料的抽烟者在卷起并抽掉⼀颗烟后会发信号通知供应者，让它继续提供另外的两种材料。这⼀过程重
复进⾏。 请⽤IPC 同步机制编程，实现该问题要求的功能。

ipc.h

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/shm.h> 
#include <sys/sem.h> 
#include <sys/msg.h> 
#define BUFSZ 256
//建⽴或获取 ipc 的⼀组函数的原型说明
int get_ipc_id(char *proc_file,key_t key);
char *set_shm(key_t shm_key,int shm_num,int shm_flag); 
int set_msq(key_t msq_key,int msq_flag);
int set_sem(key_t sem_key,int sem_val,int sem_flag); 
int down(int sem_id);
int up(int sem_id);
/*信号灯控制⽤的共同体*/ 
typedef union semuns 
{ 
	int val;
	Sem_uns;
}
/* 消 息 结 构 体 */ 
typedef struct msgbuf 
{ 
	long mtype;
	char mtext[1];
} Msg_buf;
//⽣产消费者共享缓冲区即其有关的变量
key_t buff_key;
int buff_num; 
char *buff_ptr;
//⽣产者放产品位置的共享指针
key_t pput_key; 
int pput_num; 
int *pput_ptr;
//消费者取产品位置的共享指针
key_t cget_key;
int cget_num; 
int *cget_ptr;
//⽣产者有关的信号量
key_t prod_key; 
key_t pmtx_key;
int prod_sem; 
int pmtx_sem;
//消费者有关的信号量
key_t cons_key; 
int  cons_sem; 
key_t cmtx_key;
int cmtx_sem; 

key_t x_cons_key; 
int x_cons_sem;

key_t y_cons_key; 
int y_cons_sem;

key_t z_cons_key; 
int z_cons_sem;

int sem_val; 
int sem_flg; 
int shm_flg;

生产者代码

#include "ipc.h"
int get_ipc_id(char *proc_file, key_t key) {
 FILE *pf; int i, j;
 char line[BUFSZ], colum[BUFSZ];
 if ((pf = fopen(proc_file, "r")) == NULL) {
 perror("Proc file not open");
 exit(EXIT_FAILURE);
 }
 fgets(line, BUFSZ, pf);
 while (!feof(pf)) {
 i = j = 0;
 fgets(line, BUFSZ, pf);
 while (line[i] == ' ') i++;
 while (line[i] != ' ') colum[j++] = line[i++];
 colum[j] = '\0';
 if (atoi(colum) != key) continue;
 j = 0;
 while (line[i] == ' ') i++;
 while (line[i] != ' ') colum[j++] = line[i++];
 colum[j] = '\0';
 i = atoi(colum);
 fclose(pf);
 return i;
 }
 fclose(pf);
 return -1; }
/*
* 信号灯上的down/up 操作
* semid:信号灯数组标识符
* semnum:信号灯数组下标
* buf:操作信号灯的结构
*/
int down(int sem_id) {
 buf.sem_op = -1;
 buf.sem_num = 0;
 buf.sem_flg = SEM_UNDO;
 if ((semop(sem_id, &buf, 1)) < 0) {
 perror("down error ");
 exit(EXIT_FAILURE);
 }
 return EXIT_SUCCESS; }
int up(int sem_id) {
 struct sembuf buf;
 buf.sem_op = 1;
 buf.sem_num = 0;
 buf.sem_flg = SEM_UNDO;
 if ((semop(sem_id, &buf, 1)) < 0) {
 perror("up error ");
 exit(EXIT_FAILURE);
 }
 return EXIT_SUCCESS; }
/*
* set_sem 函数建⽴⼀个具有 n 个信号灯的信号量
* 如果建⽴成功，返回 ⼀个信号灯数组的标识符 sem_id
* 输⼊参数：
* sem_key 信号灯数组的键值
* sem_val 信号灯数组中信号灯的个数
* sem_flag 信号等数组的存取权限
*/
int set_sem(key_t sem_key, int sem_val, int sem_flg) {
 int sem_id;
 Sem_uns sem_arg;
 //测试由 sem_key 标识的信号灯数组是否已经建⽴
 if ((sem_id = get_ipc_id("/proc/sysvipc/sem", sem_key)) < 0 ) {
 //semget 新建⼀个信号灯,其标号返回到 sem_id
 if ((sem_id = semget(sem_key, 1, sem_flg)) < 0) {
 perror("semaphore create error");
 exit(EXIT_FAILURE);
 }
 //设置信号灯的初值sem_arg.val = sem_val;
 if (semctl(sem_id, 0, SETVAL, sem_arg) < 0) {
 perror("semaphore set error");
 exit(EXIT_FAILURE);
 }
 }
 return sem_id; }
/*
* set_shm 函数建⽴⼀个具有 n 个字节 的共享内存区
* 如果建⽴成功，返回 ⼀个指向该内存区⾸地址的指针 shm_buf
* 输⼊参数：
* shm_key 共享内存的键值
* shm_val 共享内存字节的⻓度
* shm_flag 共享内存的存取权限
*/
char *set_shm(key_t shm_key, int shm_num, int shm_flg) {
 int i, shm_id;
 char *shm_buf;
 //测试由 shm_key 标识的共享内存区是否已经建⽴
 if ((shm_id = get_ipc_id("/proc/sysvipc/shm", shm_key)) < 0 ) {
 //shmget 新建 ⼀个⻓度为 shm_num 字节的共享内存,其标号返回shm_id
 if ((shm_id = shmget(shm_key, shm_num, shm_flg)) < 0) {
 perror("shareMemory set error"); exit(EXIT_FAILURE);
 }
 //shmat 将由 shm_id 标识的共享内存附加给指针 shm_buf
 if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
 perror("get shareMemory error"); exit(EXIT_FAILURE);
 }
 for (i = 0; i < shm_num; i++) shm_buf[i] = 0; //初始为 0
 }
 //shm_key 标识的共享内存区已经建⽴,将由 shm_id 标识的共享内存附加给指针 shm_buf
 if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
 perror("get shareMemory error");
 exit(EXIT_FAILURE);
 }
 return shm_buf; }
/*
* set_msq 函数建⽴⼀个消息队列
* 如果建⽴成功，返回 ⼀个消息队列的标识符 msq_id
* 输⼊参数：
* msq_key 消息队列的键值
* msq_flag 消息队列的存取权限
*/
int set_msq(key_t msq_key, int msq_flg) 
{
	 int msq_id;
	 //测试由 msq_key 标识的消息队列是否已经建⽴
	 if ((msq_id = get_ipc_id("/proc/sysvipc/msg", msq_key)) < 0 ) {
	 //msgget 新建⼀个消息队列,其标号返回到 msq_id
	 if ((msq_id = msgget(msq_key, msq_flg)) < 0) {
	 perror("messageQueue set error"); exit(EXIT_FAILURE);
	 }
	 }
	 return msq_id; 
 }
int main(int argc,char *argv[])
{
	int rate;
	//可在在命令⾏第⼀参数指定⼀个进程睡眠秒数，以调解进程执⾏速度  
	if (argv[1] != NULL) rate = atoi(argv[1]);
	else rate = 3; //不指定为 3 秒
	//共享内存使⽤的变量
	buff_key = 1010;//缓冲区任给的键值
	buff_num = 1;//缓冲区任给的⻓度
	pput_key = 1020;//⽣产者放产品指针的键值
	pput_num = 1; //指针数
	shm_flg = IPC_CREAT | 0644;//共享内存读写权限
	
	//获取缓冲区使⽤的共享内存，buff_ptr 指向缓冲区⾸地址
	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
	//获取⽣产者放产品位置指针 pput_ptr
	pput_ptr = (int *)set_shm(pput_key, pput_num, shm_flg);
	//信号量使⽤的变量
	prod_key = 2010;//⽣产者同步信号灯键值
	pmtx_key = 2020;//⽣产者互斥信号灯键值
	x_cons_key = 4010;//消费者同步信号灯键值
	y_cons_key = 4020;//消费者同步信号灯键值
	z_cons_key = 4030;//消费者同步信号灯键值
	cmtx_key = 4040;//消费者互斥信号灯键值
	sem_flg = IPC_CREAT | 0644;
	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
	sem_val = buff_num;
	//获取⽣产者同步信号灯，引⽤标识存 
	prod_sem prod_sem = set_sem(prod_key, sem_val, sem_flg);
	
	//消费者初始⽆产品可取，同步信号灯初值设为 0
	sem_val = 0;
	//获取消费者同步信号灯，引⽤标识存 cons_sem 
	x_cons_sem = set_sem(x_cons_key, sem_val, sem_flg); 
	y_cons_sem = set_sem(y_cons_key, sem_val, sem_flg); 
	z_cons_sem = set_sem(z_cons_key, sem_val, sem_flg);
	
	//⽣产者互斥信号灯初值为 1
	sem_val = 1;
	//获取⽣产者互斥信号灯，引⽤标识存 pmtx_sem 
	pmtx_sem = set_sem(pmtx_key, sem_val, sem_flg);
	int pid=fork(); 
	if(pid<0)
	{
		printf("create fork fail"); 
		exit(1);
	}
	else if(pid==0)
	{
		while(1)
		{
			int r=rand()%3; 
			if(r==0)
			{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem);
				
				buff_ptr[*pput_ptr]='x'; 
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(x_cons_sem);
			}
			else if(r==1)
			{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem); 
				 
				buff_ptr[*pput_ptr]='y';
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(y_cons_sem);
			}
			else{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem);  
				
				buff_ptr[*pput_ptr]='z';
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(z_cons_sem);
			}
		}
		return EXIT_SUCCESS;
	}
	else
	{
		while(1)
		{
			int r=rand()%3; 
			if(r==0)
			{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem);
				
				buff_ptr[*pput_ptr]='x'; 
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(x_cons_sem);
			}
			else if(r==1)
			{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem); 
				 
				buff_ptr[*pput_ptr]='y';
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(y_cons_sem);
			}
			else{
				//如果缓冲区满则⽣产者阻塞
				down(prod_sem);
				//如果另⼀⽣产者正在放产品，本⽣产者阻塞
				down(pmtx_sem);  
				
				buff_ptr[*pput_ptr]='z';
				sleep(rate);
				printf("child %d producer put: %c to buffer[%d]\n",getpid(),buff_ptr[*pput_ptr],*pput_ptr);
				//唤醒阻塞的⽣产者
				up(pmtx_sem);
				//唤醒阻塞的消费者
				up(z_cons_sem);
			}
		}
	}
	return EXIT_SUCCESS;
}

消费者代码

#include "ipc.h"
int get_ipc_id(char *proc_file, key_t key) {
 FILE *pf; int i, j;
 char line[BUFSZ], colum[BUFSZ];
 if ((pf = fopen(proc_file, "r")) == NULL) {
 perror("Proc file not open");
 exit(EXIT_FAILURE);
 }
 fgets(line, BUFSZ, pf);
 while (!feof(pf)) {
 i = j = 0;
 fgets(line, BUFSZ, pf);
 while (line[i] == ' ') i++;
 while (line[i] != ' ') colum[j++] = line[i++];
 colum[j] = '\0';
 if (atoi(colum) != key) continue;
 j = 0;
 while (line[i] == ' ') i++;
 while (line[i] != ' ') colum[j++] = line[i++];
 colum[j] = '\0';
 i = atoi(colum);
 fclose(pf);
 return i;
 }
 fclose(pf);
 return -1; }
/*
* 信号灯上的down/up 操作
* semid:信号灯数组标识符
* semnum:信号灯数组下标
* buf:操作信号灯的结构
*/
int down(int sem_id) {
 buf.sem_op = -1;
 buf.sem_num = 0;
 buf.sem_flg = SEM_UNDO;
 if ((semop(sem_id, &buf, 1)) < 0) {
 perror("down error ");
 exit(EXIT_FAILURE);
 }
 return EXIT_SUCCESS; }
int up(int sem_id) {
 struct sembuf buf;
 buf.sem_op = 1;
 buf.sem_num = 0;
 buf.sem_flg = SEM_UNDO;
 if ((semop(sem_id, &buf, 1)) < 0) {
 perror("up error ");
 exit(EXIT_FAILURE);
 }
 return EXIT_SUCCESS; }
/*
* set_sem 函数建⽴⼀个具有 n 个信号灯的信号量
* 如果建⽴成功，返回 ⼀个信号灯数组的标识符 sem_id
* 输⼊参数：
* sem_key 信号灯数组的键值
* sem_val 信号灯数组中信号灯的个数
* sem_flag 信号等数组的存取权限
*/
int set_sem(key_t sem_key, int sem_val, int sem_flg) {
 int sem_id;
 Sem_uns sem_arg;
 //测试由 sem_key 标识的信号灯数组是否已经建⽴
 if ((sem_id = get_ipc_id("/proc/sysvipc/sem", sem_key)) < 0 ) {
 //semget 新建⼀个信号灯,其标号返回到 sem_id
 if ((sem_id = semget(sem_key, 1, sem_flg)) < 0) {
 perror("semaphore create error");
 exit(EXIT_FAILURE);
 }
 //设置信号灯的初值sem_arg.val = sem_val;
 if (semctl(sem_id, 0, SETVAL, sem_arg) < 0) {
 perror("semaphore set error");
 exit(EXIT_FAILURE);
 }
 }
 return sem_id; }
/*
* set_shm 函数建⽴⼀个具有 n 个字节 的共享内存区
* 如果建⽴成功，返回 ⼀个指向该内存区⾸地址的指针 shm_buf
* 输⼊参数：
* shm_key 共享内存的键值
* shm_val 共享内存字节的⻓度
* shm_flag 共享内存的存取权限
*/
char *set_shm(key_t shm_key, int shm_num, int shm_flg) {
 int i, shm_id;
 char *shm_buf;
 //测试由 shm_key 标识的共享内存区是否已经建⽴
 if ((shm_id = get_ipc_id("/proc/sysvipc/shm", shm_key)) < 0 ) {
 //shmget 新建 ⼀个⻓度为 shm_num 字节的共享内存,其标号返回shm_id
 if ((shm_id = shmget(shm_key, shm_num, shm_flg)) < 0) {
 perror("shareMemory set error"); exit(EXIT_FAILURE);
 }
 //shmat 将由 shm_id 标识的共享内存附加给指针 shm_buf
 if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
 perror("get shareMemory error"); exit(EXIT_FAILURE);
 }
 for (i = 0; i < shm_num; i++) shm_buf[i] = 0; //初始为 0
 }
 //shm_key 标识的共享内存区已经建⽴,将由 shm_id 标识的共享内存附加给指针 shm_buf
 if ((shm_buf = (char *)shmat(shm_id, 0, 0)) < (char *)0) {
 perror("get shareMemory error");
 exit(EXIT_FAILURE);
 }
 return shm_buf; }
/*
* set_msq 函数建⽴⼀个消息队列
* 如果建⽴成功，返回 ⼀个消息队列的标识符 msq_id
* 输⼊参数：
* msq_key 消息队列的键值
* msq_flag 消息队列的存取权限
*/
int set_msq(key_t msq_key, int msq_flg) 
{
	 int msq_id;
	 //测试由 msq_key 标识的消息队列是否已经建⽴
	 if ((msq_id = get_ipc_id("/proc/sysvipc/msg", msq_key)) < 0 ) {
	 //msgget 新建⼀个消息队列,其标号返回到 msq_id
	 if ((msq_id = msgget(msq_key, msq_flg)) < 0) {
	 perror("messageQueue set error"); exit(EXIT_FAILURE);
	 }
	 }
	 return msq_id; 
 }
int main(int argc,char *argv[])
{
	int rate;
	//可在在命令⾏第⼀参数指定⼀个进程睡眠秒数，以调解进程执⾏速度  
	if (argv[1] != NULL) rate = atoi(argv[1]);
	else rate = 3; //不指定为 3 秒
	//共享内存使⽤的变量
	buff_key = 1010;//缓冲区任给的键值
	buff_num = 1;//缓冲区任给的⻓度
	pput_key = 1020;//⽣产者放产品指针的键值
	pput_num = 1; //指针数
	shm_flg = IPC_CREAT | 0644;//共享内存读写权限
	
	//获取缓冲区使⽤的共享内存，buff_ptr 指向缓冲区⾸地址
	buff_ptr = (char *)set_shm(buff_key, buff_num, shm_flg);
	//获取⽣产者放产品位置指针 pput_ptr
	pput_ptr = (int *)set_shm(pput_key, pput_num, shm_flg);
	//信号量使⽤的变量
	prod_key = 2010;//⽣产者同步信号灯键值
	pmtx_key = 2020;//⽣产者互斥信号灯键值
	x_cons_key = 4010;//消费者同步信号灯键值
	y_cons_key = 4020;//消费者同步信号灯键值
	z_cons_key = 4030;//消费者同步信号灯键值
	cmtx_key = 4040;//消费者互斥信号灯键值
	sem_flg = IPC_CREAT | 0644;
	
	//⽣产者同步信号灯初值设为缓冲区最⼤可⽤量
	sem_val = buff_num;
	//获取⽣产者同步信号灯，引⽤标识存 
	prod_sem prod_sem = set_sem(prod_key, sem_val, sem_flg);
	
	//消费者初始⽆产品可取，同步信号灯初值设为 0
	sem_val = 0;
	//获取消费者同步信号灯，引⽤标识存 cons_sem 
	x_cons_sem = set_sem(x_cons_key, sem_val, sem_flg); 
	y_cons_sem = set_sem(y_cons_key, sem_val, sem_flg); 
	z_cons_sem = set_sem(z_cons_key, sem_val, sem_flg);
	
	//消费者互斥信号灯初值为 1
	sem_val = 1;
	//获取消费者互斥信号灯，引⽤标识存 cmtx_sem; 
	cmtx_sem = set_sem(cmtx_key, sem_val, sem_flg);
	int pid1,pid2; 
	pid1=fork(); 
	if(pid1<0)
	{
		printf("create fork pid1 fail\n"); 
		exit(1);
	}
	else if(pid1==0)
	{
		while(1){
			//若没有相应产品，消费者阻塞
			down(x_cons_sem);
			//如果另一消费者正在取产品,本消费者阻塞
			down(cmtx_sem);
			sleep(rate);
			printf("%d 进程拥有 x,得到另外两种材料，可以抽烟\n",getpid());
			//唤醒阻塞的消费者
			up(cmtx_sem);
			//唤醒阻塞的生产者
			up(prod_sem);
		}
	}
	else{
		pid2=fork(); 
		if(pid2<0)
		{
			printf("create fork pid2 fail\n"); 
			exit(1);
		}
		else if(pid2==0)
		{
			while(1)
			{
				//若没有相应产品，消费者阻塞
				//printf("%d\n",y_cons_sem); 
				down(y_cons_sem);
				//如果另一消费者正在取产品,本消费者阻塞
				//puts("234"); 
				down(cmtx_sem); 
				sleep(rate);
				printf("%d 进程拥有 y,得到另外两种材料，可以抽烟\n",getpid());
				//唤醒阻塞的消费者
				up(cmtx_sem);
				//唤醒阻塞的生产者
				up(prod_sem);
			}
		}
		else{
			while(1)
			{
			//若没有相应产品，消费者阻塞
			down(z_cons_sem);
			//如果另一消费者正在取产品,本消费者阻塞
			down(cmtx_sem);
			sleep(rate);
			printf("%d 进程拥有 z,得到另外两种材料，可以抽烟\n",getpid());
			//唤醒阻塞的消费者
			up(cmtx_sem);
			//唤醒阻塞的生产者
			up(prod_sem);
			}
		}
	}
	return EXIT_SUCCESS;
}
sdu_wzj
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统实验四 进程同步实验
05-14
操作系统实验报告四 进程同步实验报告。加深对并发协作进程同步与互斥概念的理解，观察和体验并发进程同步与互斥操作的效果，分析与研究经典进程同步与互斥问题的实际解决方案。了解Linux系统中IPC进程同步工具的用法，练习并发协作进程的同步与互斥操作的编程与调试技术。
【操作系统】进程同步实验
热门推荐
cout0
11-29 1万+
文章目录实验目的实验内容实验原理实验准备实现步骤相关函数CreateThreadCreateMutexReleaseMutexCreateSemaphoreReleaseSemaphoreWaitForSingleObjectSleep实验过程源代码实验心得 实验目的 分析进程的同步与互斥现象，编程实现经典的进程同步问题——生产者与消费者问题的模拟，进一步加深对进程同步与互斥的理解。 实验内容 用...
实验 5 进程的同步
qq_44047806的博客
06-06 5209
实验 5 进程的同步 一、实验目的 1.使用 EOS 的信号量，编程解决生产者—消费者问题，理解进程同步的意义。 2.调试跟踪 EOS 信号量的工作过程，理解进程同步的原理。 3.修改 EOS 的信号量算法，使之支持等待超时唤醒功能（有限等待），加深理解进程同的原理。 二、实验内容 2.1准备实验 请读者按照下面方法之一在本地创建项目，用于完成本次实验： 方法一：从 CodeCode.net 平台领取任务 读者需要首先登录 CodeCode.net 平台领取本次实验对应的两个任务，从而在 CodeCode.
实验二 进程（线程）同步
Olivia_su的博客
04-18 1604
sem_init函数是Linux中初始化信号量的函数，它的第一个参数sem用来传入需要初始化的信号量地址，第二个参数pshared值是用来表示该信号量是由进程内线程共享还是由进程之间共享，如果它的值设为0，那么该信号量将被进程内的线程共享（本实验所有线程都属于同一进程，故pshared的值设置为0即可）。sem_post函数相当于操作系统中所学的信号量操作中signal操作，即对信号量中的整型值进行加1。第二个参数用来设置线程属性。它的功能是创建以第三个参数start_routine为入口函数的线程。
进程同步与互斥：Windows环境
m0_52435951的博客
06-26 1391
一、实验目的： 1． 掌握基本的同步与互斥算法，理解P，V操作。 2． 理解生产者消费者模型，了解其它典型的同步互斥模型，如哲学家就餐、读者－写者模型等。 3． 了解LINUX中进程同步互斥的实现方法，掌握相关函数的使用方法。 4． 学习使用Windows中基本的同步对象，掌握相关API的使用方法。 5． 了解Windows中多线程的并发执行机制，实现进程的同步与互斥。 二、实验环境： Windows环境 三、实验内容： PART 2　Windows环境 一、相关知识介绍 1． 同步对象 同步对象是指Win
操作系统实验报告——进程同步与互斥.doc
12-22
操作系统实验报告——进程同步与互斥.doc
操作系统实验报告——进程同步与互斥.pdf
12-19
操作系统实验报告——进程同步与互斥.pdf
操作系统实验报告——进程同步和互斥.doc
10-12
操作系统实验报告——进程同步和互斥.doc
操作系统原理实验-进程同步
cangzhexingxing的博客
05-19 7557
操作系统原理实验报告 实验题目 实验二进程同步 实验二、进程同步 1.1 实验目的 现代操作系统的核心是多道程序设计、多处理器和分布式处理器，这些方案和操作系统设计技术的基础都是并发。当多个进程并发执行时，不论是在多处理器系统的情况下，还是在单处理器多道程序系统中，都会出现冲突和合作的问题。 理解操作系统中用互斥和同步解决问题。 用信号量机制分别实现读者优先和写者优先的读者-写者问题从而掌握互斥与同步的基本理念。 1.2 实验内容及要求 在Windows 环...
操作系统——进程同步实验
qq_60880381的博客
12-15 1108
这个实验是关于生产者和消费者问题的并发编程实验，通过共享内存和信号量来实现生产者和消费者之间的同步与互斥。在这个实验中，我们首先创建了一个共享内存区域，用来作为生产者和消费者之间的缓冲区。然后，我们创建了三个信号量，分别用于表示缓冲区的状态（非空、非满）、互斥访问缓冲区以及共享数据的个数。通过对这些信号量的操作，实现了生产者和消费者之间的协调和互斥访问。在主程序中，我们创建了若干个生产者和消费者进程，并通过 fork() 系统调用来创建子进程。
进程同步实验（山东大学操作系统实验）
04-09
山东大学操作系统实验第六个，进程同步的源代码
操作系统实验：进程同步控制
m0_72471315的博客
03-30 2728
这篇文章是从网页内容中摘要的。它是一篇关于操作系统实验中的进程同步控制问题，以及如何使用java或c语言编写相关的程序的文章。文章主要包括以下几个部分： 实验目的和要求：让学生理解进程同步的概念和方法，以及掌握java或c语言的多线程编程技巧。 实验设计思路：模拟一个生产者-消费者问题，使用信号量机制来实现进程间的同步和互斥。 实验代码实现：设计一个缓冲区类，一个生产者类，一个消费者类，以及一个主类来控制程序的运行。 实验结果分析：程序能够正确地运行，并且没有出现死锁或数据丢失的情况。
操作系统实验之进程同步
最新发布
lwcwam的博客
01-21 1107
操作系统实验之进程同步
操作系统 吸烟者问题 进程的同步互斥
QER 的博客
11-20 607
操作系统 吸烟者问题 进程的同步互斥 这个解释的挺清楚的：https://www.cnblogs.com/wkfvawl/p/11534452.html 代码： producer.c #include "ipc.h" int main(int argc, char *argv[]) { int rate; //可在在命令⾏第⼀参数指定⼀个进程睡眠秒数，以调解进程执⾏速度 if (argv[1] != NULL) rate = atoi(argv[1]); else rate = 3; //不
【操作系统】实验三 进程的互斥与同步
AGATHA_66的博客
01-11 1059
本人一直想找时间系统整理一下之前做过的一些实验，便于后续用到的时候可以尽快的使用，po出来也便于大家交流学习，有问题欢迎交流指正，与诸君共勉！操作系统实验三，进程的互斥与同步。
【此后无良辰】实验5 进程的同步
qq_40493829的博客
08-03 3670
实验目的 掌握使用信号量编程解决进程/线程同步互斥问题的方法；了解操作系统进程/线程同步的原理。 实验内容与记录 3.2 该实验给出的是单人单缓-单人多缓-多人单缓-多人多缓中的哪一个问题实现？程序通过什么方式实现了生产者比消费者快的同步过程？在这种情况下，为什么生产者在生产了13号产品后还会阻塞？ （1） 单人多缓 （2） 实现方式： 消费者在前十四个每2000ms询问消费一次，后十四个每隔100ms询问消费一次。 生产者每隔500ms产生。 因此可以保证在前十四个消费者时，生产者的生产速度大于消费者
计算机操作系统实验报告：进程同步与互斥
pengfuqiang521的博客
11-08 1637
进程同步与互斥。
操作系统进程的同步与互斥实验
qq_63010042的博客
06-25 254
1、掌握用信号量机制解决进程的同步与互斥问题。 2、掌握生产者消费者问题的算法描述。 3、掌握用高级语言模拟生产者消费者问题的实现。
操作系统进程同步实验报告
cfqp123456的博客
06-14 6009
操作系统进程同步实验报告
2021-11-02 操作系统实验3——生产者消费者实验
05-23
生产者消费者问题是一个经典的同步问题，其中生产者和消费者共享一个缓冲区，生产者向缓冲区中生产产品，消费者从缓冲区中消费产品。在多线程的环境下，生产者和消费者可能会同时访问缓冲区，因此需要对缓冲区进行同步控制。 以下是一个简单的生产者消费者问题的实现： ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define BUFFER_SIZE 10 int buffer[BUFFER_SIZE]; int count = 0; int in = 0; int out = 0; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t empty = PTHREAD_COND_INITIALIZER; pthread_cond_t full = PTHREAD_COND_INITIALIZER; void *producer(void *arg) { int i; for (i = 0; i < 20; i++) { pthread_mutex_lock(&mutex); while (count == BUFFER_SIZE) { pthread_cond_wait(&empty, &mutex); } buffer[in] = i; in = (in + 1) % BUFFER_SIZE; count++; printf("producer: produced %d\n", i); pthread_cond_signal(&full); pthread_mutex_unlock(&mutex); } pthread_exit(NULL); } void *consumer(void *arg) { int i, data; for (i = 0; i < 20; i++) { pthread_mutex_lock(&mutex); while (count == 0) { pthread_cond_wait(&full, &mutex); } data = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; printf("consumer: consumed %d\n", data); pthread_cond_signal(&empty); pthread_mutex_unlock(&mutex); } pthread_exit(NULL); } int main() { pthread_t tid1, tid2; pthread_create(&tid1, NULL, producer, NULL); pthread_create(&tid2, NULL, consumer, NULL); pthread_join(tid1, NULL); pthread_join(tid2, NULL); return 0; } ``` 在代码中，我们定义了一个大小为10的缓冲区，使用一个计数器count来记录缓冲区中产品的数量，in和out分别表示生产者和消费者在缓冲区中的位置。我们使用了两个条件变量empty和full来控制生产者消费者的同步。 在生产者中，当缓冲区已满时，生产者会等待empty条件变量，直到缓冲区有空位。当生产者生产完一个产品后，会唤醒消费者，并释放互斥锁。 在消费者中，当缓冲区为空时，消费者会等待full条件变量，直到缓冲区有产品。当消费者消费完一个产品后，会唤醒生产者，并释放互斥锁。 通过使用互斥锁和条件变量，我们可以保证生产者和消费者的正确同步，避免了竞争条件和死锁等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值