利用信号量机制实现生产者消费者问题（用进程通信进行模拟）

最新推荐文章于 2022-07-27 19:13:22 发布
最新推荐文章于 2022-07-27 19:13:22 发布
阅读量5.8k 收藏 46
点赞数 5
分类专栏： 操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41648012/article/details/90737724
版权

生产者消费者同步问题：生产者进程产生消息放在某个共享资源区，共享资源区的消息不为空时消费者进程从该共享资源区读取消息，为了避免脏读生产者和消费者不能同时访问共享资源，这就涉及到生产者和消费者进程之间的同步。利用信号量解决该问题：
定义两个信号量（不能是一个，否则生产者或者消费者可能会无限的访问共享资源，形成死循环）S1、S2，初始值为1，0。S1=1表示生产者进程可写共享资源，为0则不可；S2=1表示消费者进程可读共享资源，为0则不可。伪代码描述如下：

    生产者进程：
    whlie(true)
    {
        产生一个消息
    	P(S1)
    	消息写到共享资源
    	V(S2)
    }
     
    消费者进程：
    whlie(true)
    {
    	P(S2)
    	从共享资源读取消息
    	V(S1)
    	处理消息
    }

1.信号量
信号量可用于多进程的同步，为多个进程提供对共享资源的访问。

(1)获取信号量

int semget(key_t key, int semnum, int flag);

semnum为信号数量，如果是新创建信号量，则大于0;如果是打开已有的信号量，则semnum可为0;

(2)对信号量进行操作

int semctl(int semid, int semnm, int cmd [, union semun arg]);

参数semnm是信号量集合中某个信号量的下标，从0开始，在0与nsems-1之间;
参数中联合体结构如下（有些系统需要自定义）：

    union semun 
    {
       int val;                 /*for SETVAL*/
       struct semid_ds *buf;    /*for IPC_STAT  IPC_SET*/
       unsigned short *array;   /*for SETALL*/
    };

这里union semun arg是可选参数，例如cmd=IPC_RMID就不需要该参数，cmd为SETVAL或者SETALL的时候需要该参数。
以cmd=SETALL时，此时信号量集合的值由arg.array数组指定。

(3)自动执行信号量集合上的操作数组 semop是原子操作

int semctl(int semid, int semnm, int cmd [, union semun arg]);

其中结构体struct sembuf在(sys/sem.h)中定义如下：

    struct sembuf
    {
       unsigned short sem_num;      /*0~nsems-1*/
       short sem_op;                /*negative, 0, pasitive*/
       short sem_flg;               /*0 IPC_UNDO  IPC_NOWAIT*/
    };

输入域参数semoparray指向一个信号量操作结构体数组，参数nops是操作的信号量的个数。

这里可以看用semop可以包装P、V操作，以便实现进程之间的同步，这里回顾一下PV操作。
定义一个信号量sem，则有：
P操作：令sem=sem-1，若sem>=0，则进程继续执行，否则挂起等待，加入等待队列。
V操作：令sem=sem+1，若sem<0，唤醒等待队列中的一个进程。(注意：sem<0才需要唤醒，因为此时有阻塞； s>=0说明没阻塞也不需要唤醒)。

2.共享内存
共享内存是IPC的一种，共享内存为多个进程提供一个可以共同访问的存储区，共享内存的数据，不需要在各个进程间复制，因此是速度最快的IPC。多个进程访问共享内存时，为了避免脏读，需要实现进程的同步，通常用信号量实现共享内存的同步访问。
共享内存的接口函数如下：
（1）创建或者获得共享内存

int shmget(key_t key, size_t size, int flag);

（2）共享内存操作

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

（3）链接共享内存

void *shmat(int shmid, const void *arr,  int flag);  //成功返回共享内存的指针，否则返回NULL

addr通常使用NULL，表示链接到内核选择的第一个可用地址上;
addr非NULL，且没有指定flag为SHM_RND则链接到arr指定的地址；
addr非NULL，且指定了flag为SHM_RND则连接到arr-(addr mod SHMLBA)表示的地址，就是向下取近1个SHMLBA的倍数数
flag如果为RDONLY，则共享内存只读

（4）结束共享内存段访问（并未删除）

int shmdt(const void *shmArr);   //分离链接的共享内存，成功返回0，失败-1

shmArr是shmat返回的值。

3.信号量与共享内存解决生产者消费者问题
生产者进程负责从键盘读取消息写入到共享内存，消费者进程从共享内存读数据输出到屏幕，生产者进程写共享内存结束前，消费者进程不能读；消费者进程读共享内存时，生产者进程不能写共享内存。
（1）shm_sem.h

# ifndef _SHM_SEM_H
# define _SHM_SEM_H
 
# define SHM_KEY 38111
# define SEM_KEY 38222
# define SHM_SIZE 2048
# define SEM_NUM  2
 
int sem_p(int semid, int semnum);
int sem_v(int semid, int semnum);
int get_semval(int semid, int semnum);
 
union semun
{
	int val;                 /*for SETVAL*/
	struct semid_ds *buf;    /*for IPC_STAT  ans  IPC_SET*/
	unsigned short *array;   /*for GETALL  ans  SET_ALL*/
};
 
 
# endif

（2）pubfun.c

#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
#include <unistd.h> 
#include <errno.h> 
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <sys/sem.h> 
 
/*sem P*/ 
int sem_p(int semid, int semnum)    
{
	/*int semop(int semid, struct sembuf semoparray[], size_t cnts); */
	struct sembuf semOpr ;
	
	semOpr.sem_num = semnum;
	semOpr.sem_op  = -1;
	semOpr.sem_flg = SEM_UNDO;
	
	return semop(semid, &semOpr, 1);
}
 
/*sem V*/ 
int sem_v(int semid, int semnum)
{
	/*int semop(int semid, struct sembuf semoparray[], size_t cnts); */
	struct sembuf semOpr ;
	
	semOpr.sem_num = semnum;
	semOpr.sem_op  = 1;
	semOpr.sem_flg = SEM_UNDO;
	
	return semop(semid, &semOpr, 1);
}
 
/*get semval*/ 
int get_semval(int semid, int semnum)
{
	return semctl(semid, semnum, GETVAL);
}

（3）server.c 生产者进程

#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
#include <unistd.h> 
#include <errno.h> 
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <sys/shm.h> 
#include <sys/sem.h> 
 
#include "shm_sem.h"
 
# if 0
struct sembuf
{
   unsigned short sem_num;      /*0-nsems-1*/
   short sem_op;                /*negative, 0, pasitive*/
   short sem_flg;               /*0 IPC_UNDO  IPC_NOWAIT*/
}
#endif

int main(void)
{
	int ret;
	int shmid;
	int semid;
	void *ptrShm = NULL;
	struct shmid_ds shm_ds;
	struct semid_ds sem_ds;
	char buf[1024] = {0};
	union semun arg;
	unsigned short semvalArr[SEM_NUM] = {1, 0};
	
	memset(&shm_ds, 0x00, sizeof(shm_ds));
	memset(&sem_ds, 0x00, sizeof(sem_ds));
	
	/*semget*/
	semid = semget((key_t)SEM_KEY, SEM_NUM, 0660|IPC_CREAT|IPC_EXCL);   /*int semget(key_t key, int nsems, int flag);*/
	if(semid == -1)
	{
		if(errno == EEXIST) /*no need to init sem*/
		{
			printf("semget() warning: %s\n", strerror(errno));
			semid = semget((key_t)SEM_KEY, 0, 0660|IPC_CREAT); /*nsems can be 0 when semid already exists*/
			if(semid == -1)
			{
				printf("semget() error: %s\n", strerror(errno));
				return -1;
			}
			printf("semget() success. semid=[%d]\n", semid);
		}
		else
		{
			printf("semget() error: %s\n", strerror(errno));
			return -1;
		}
	}
	else  /*need to init sem*/
	{
		printf("semget() success. semid=[%d]\n", semid);
				
		/*semctl(): init sem, set semvalArr[0]=1 semvalArr[1]=0*/
        arg.array = semvalArr;		
		ret = semctl(semid, 0, SETALL, arg);  /*int semctl(int semid, int semnm, int cmd [, union semun arg]); semnum between 0~nsems-1*/ 
		if(ret == -1)
		{
			printf("semctl() SETALL error: %s\n", strerror(errno));
			printf("init sem error.\n");
			
		   /*semctl IPC_RMID*/
	       ret = semctl(semid, 0, IPC_RMID);
	       if(ret == -1)
	       {
	       	printf("semctl() error: %s\n", strerror(errno));
	       }
	       printf("semctl() success. Sem is deleted.\n"); 
		   return -1;
		   
		}
		printf("semget() success.\n");
		
	}
	printf("init sem success. semval[0]=[%d] semval[1]=[%d].\n", get_semval(semid, 0), get_semval(semid, 1));
	
 
	/*shmget*/
	shmid = shmget((key_t)SHM_KEY, SHM_SIZE, 0660|IPC_CREAT|IPC_EXCL);   /*int shmget(key_t key, size_t size, int flag);*/
	if(shmid == -1)
	{
		if(errno == EEXIST)
		{
			printf("shmget() warning: %s\n", strerror(errno));
			shmid = shmget((key_t)SHM_KEY, SHM_SIZE, 0660|IPC_CREAT);
			if(shmid == -1)
			{
				printf("shmget() error: %s\n", strerror(errno));
				return -1;
			}
		}
		else
		{
			printf("shmget() error: %s\n", strerror(errno));
			return -1;
		}
	}
	printf("shmget() success. shmid=[%d]\n", shmid); 
		
	
	/*shmat*/
	ptrShm = shmat(shmid, NULL, !SHM_RDONLY);   /*void *shmat(int shmid, const void *shmarr,  int flag);*/
	if(ptrShm == NULL)
	{
		printf("shmat() error: %s\n", strerror(errno));
		goto FAILED;
	}
	printf("shmat() success.\n"); 
	
	/*Begin to write*/
	printf("Begin to write shared memory.\n"); 
	while(1)
	{
		
	    /*input*/
		memset(&buf, 0x00, sizeof(buf));
		
		
		printf("server: ");
		if(fgets(buf, sizeof(buf)-1, stdin) < 0)
		{
			printf("fgets() error\n");
			fflush(stdin);
			continue;
		}
		fflush(stdin);
		
		/*P*/
		ret = sem_p(semid, 0);
		if(ret == -1)
		{
			printf("sem_p() error\n");
			goto FAILED;
			
		}
		
		/*write into shm*/
		memset(ptrShm, 0x00, SHM_SIZE);
		memcpy((char*)ptrShm, buf, strlen(buf));
				
		/*V*/
		ret = sem_v(semid, 1);
		if(ret == -1)
		{
			printf("sem_v() error\n");
			goto FAILED;
			
		}
		if(memcmp(buf, "exit", 4) == 0)
		{
			break;
		}
		
	}
	
	
	/*shmdt*/
	ret = shmdt(ptrShm);
	if(ret == -1)
	{
		printf("shmdt() error: %s\n", strerror(errno));
	}
	printf("shmdt() success.\n"); 
	
	return 0;
	
FAILED:
	/*shmctl IPC_RMID*/
	ret = shmctl(shmid, IPC_RMID, &shm_ds);
	if(ret == -1)
	{
		printf("shmctl() error: %s\n", strerror(errno));
	}
	printf("shmctl() success. Shm is deleted.\n"); 
	
	
	/*semctl IPC_RMID*/
	ret = semctl(semid, 0, IPC_RMID);
	if(ret == -1)
	{
		printf("semctl() error: %s\n", strerror(errno));
	}
	printf("semctl() success. Sem is deleted.\n"); 
	
	return -1;
	
}

（4）client.c 消费者进程

#include <stdio.h>  
#include <string.h>  
#include <stdlib.h>  
#include <unistd.h> 
#include <errno.h> 
#include <sys/types.h>  
#include <sys/ipc.h>  
#include <sys/shm.h> 
#include <sys/sem.h> 
 
#include "shm_sem.h"

int main(void)
{
	int ret;
	int shmid;
	int semid;
	void *ptrShm = NULL;
	struct shmid_ds shm_ds;
	struct semid_ds sem_ds;
	char buf[1024] = {0};
	union semun arg;
	unsigned short semvalArr[SEM_NUM];
		
	memset(&shm_ds, 0x00, sizeof(shm_ds));
	memset(&sem_ds, 0x00, sizeof(sem_ds));
	
	/*semget*/
	semid = semget((key_t)SEM_KEY, SEM_NUM, 0660|IPC_CREAT|IPC_EXCL);   /*int semget(key_t key, int nsems, int flag);*/
	if(semid == -1)
	{
		if(errno == EEXIST) /*no need to init sem*/
		{
			printf("semget() warning: %s\n", strerror(errno));
			semid = semget((key_t)SEM_KEY, 0, 0660|IPC_CREAT); /*nsems can be 0 when semid already exists*/
			if(semid == -1)
			{
				printf("semget() error: %s\n", strerror(errno));
				return -1;
			}
			printf("semget() success. semid=[%d]\n", semid);
		}
		else
		{
			printf("semget() error: %s\n", strerror(errno));
			return -1;
		}
	}
	else  /*need to init sem*/
	{
		printf("semget() success. semid=[%d]\n", semid);
				
		/*semctl(): init sem, set semvalArr[0]=1 semvalArr[1]=0*/
		semvalArr[0]= (unsigned short)1 ;
		semvalArr[1]= (unsigned short)0 ;
        arg.array = semvalArr;		
		ret = semctl(semid, 0, SETALL, arg);  /*int semctl(int semid, int semnm, int cmd [, union semun arg]); semnum between 0~nsems-1*/ 
		if(ret == -1)
		{
			printf("semctl() SETALL error: %s\n", strerror(errno));
			printf("init sem error.\n");
			
		   /*semctl IPC_RMID*/
	       ret = semctl(semid, 0, IPC_RMID);
	       if(ret == -1)
	       {
	       	printf("semctl() error: %s\n", strerror(errno));
	       }
	       printf("semctl() success. Sem is deleted.\n"); 
		   return -1;
		   
		}
		printf("semget() success.\n");
		
	}
	printf("semval[0]=[%d] semval[1]=[%d].\n", get_semval(semid, 0), get_semval(semid, 1));
	
	/*shmget*/
	shmid = shmget((key_t)SHM_KEY, SHM_SIZE, 0660|IPC_CREAT|IPC_EXCL);   /*int shmget(key_t key, size_t size, int flag);*/
	if(shmid == -1)
	{
		if(errno == EEXIST)
		{
			printf("shmget() warning: %s\n", strerror(errno));
			shmid = shmget((key_t)SHM_KEY, SHM_SIZE, 0660|IPC_CREAT);
			if(shmid == -1)
			{
				printf("shmget() error: %s\n", strerror(errno));
				return -1;
			}
		}
		else
		{
			printf("shmget() error: %s\n", strerror(errno));
			return -1;
		}
	}
	printf("shmget() success. shmid=[%d]\n", shmid);   
	
	/*shmat*/
	ptrShm = shmat(shmid, NULL, SHM_RDONLY);   /*void *shmat(int shmid, const void *shmarr,  int flag);*/
	if(ptrShm == NULL)
	{
		printf("shmat() error: %s\n", strerror(errno));
		goto FAILED;
	}
	printf("shmat() success.\n"); 
	printf("Begin to read shared memory.\n"); 
	
    //防止消费者在生产者之前启动，导致死锁
	while(1)
	{
		/*test semvalArr[0]*/
		ret = get_semval(semid, 1);
		if(ret < 0) /**/
		{
			printf("get_semval() error.\n");
			goto FAILED;
		}
		else if(ret == 0)   /*It suggests that the server hasn't start yet*/
			continue;
		else
			break;
	}
	
	/*Begin to read*/
	while(1)
	{
		/*P*/
		ret = sem_p(semid, 1);
		if(ret == -1)
		{
			printf("sem_p() error\n");
			goto FAILED;
			
		}
		
	    /*read shm*/
		memset(&buf, 0x00, sizeof(buf));
		memcpy(buf, (char*)ptrShm, sizeof(buf));
		
		
		/*V*/
		ret = sem_v(semid, 0);
		if(ret == -1)
		{
			printf("sem_v() error\n");
			goto FAILED;
			
		}
		
		printf("client: %s", buf);
		if(buf[0]=='\0')
			printf("\n");
			
		if(memcmp(buf, "exit", 4) == 0)
		{
			break;
		}
		
	}
	
	
	/*shmdt*/
	ret = shmdt(ptrShm);
	if(ret == -1)
	{
		printf("shmdt() error: %s\n", strerror(errno));
	}
	printf("shmdt() success.\n"); 
	
	/*shmctl IPC_RMID*/
	ret = shmctl(shmid, IPC_RMID, &shm_ds);
	if(ret == -1)
	{
		printf("shmctl() error: %s\n", strerror(errno));
	}
	printf("shmctl() success. Shm is deleted.\n"); 
	
	/*semctl IPC_RMID*/
	ret = semctl(semid, 0, IPC_RMID);
	if(ret == -1)
	{
		printf("semctl() error: %s\n", strerror(errno));
	}
	printf("semctl() success. Sem is deleted.\n"); 
	
	return 0;
	
FAILED:
	/*shmctl IPC_RMID*/
	ret = shmctl(shmid, IPC_RMID, &shm_ds);
	if(ret == -1)
	{
		printf("shmctl() error: %s\n", strerror(errno));
	}
	printf("shmctl() success. Shm is deleted.\n"); 
	
	/*semctl IPC_RMID*/
	ret = semctl(semid, 0, IPC_RMID);
	if(ret == -1)
	{
		printf("semctl() error: %s\n", strerror(errno));
	}
	printf("semctl() success. Sem is deleted.\n"); 
	
	return -1;
}

（5）makefile
编译

gcc -c pubfun.c
gcc -c server.c
gcc -c client.c
gcc pubfun.o server.o -o server
gcc pubfun.o client.o -o client

运行

./server
./client

测试结果
在这里插入图片描述在这里插入图片描述
在这里插入图片描述server进程输入exit则结束进程，client读取到exit后结束进程并删除共享内存和信号量。

Forever_Young_L
关注
  • 5
    点赞
  • 踩
  • 46
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Win丨linux丨操作系统实验二：生产者——消费者问题
05-13
操作系统实验二：生产者——消费者问题 1. 在Windows操作系统上，利用Win32 API提供的信号量机制，编写应用程序实现生产者——消费者问题。 2. 在Linux操作系统上，利用Pthread API提供的信号量机制，编写应用程序实现生产者——消费者问题。 3. 两种环境下，生产者和消费者均作为独立线程，并通过empty、full、mutex三个信号量实现对缓冲进行插入与删除。 4. 通过打印缓冲区中的内容至屏幕，来验证应用程序的正确性。
多线程代码 经典线程同步互斥问题 生产者消费者问题
06-01
a: 创建一个线程 b: 创建多个线程 c: 多线程访问同一资源 d: 经典线程同步互斥问题 e: 使用关键段解决子线程互斥问题 f: 利用事件实现线程同步问题 g: 利用互斥量来解决线程同步互斥问题 h: problem1 生产者消费者问题 (1生产者 1消费者 1缓冲区) problem1 more 生产者消费者问题 (1生产者 2消费者 4缓冲区) problem2 读者与写着问题 I: 信号量 semaphore 解决线程同步问题
操作系统上机实验报告 进程同步和通信-生产者和消费者问题模拟
07-18
1. 目的： 调试、修改、运行模拟程序，通过形象化的状态显示，使学生理解进程的概念，了解同步和通信的过程，掌握进程通信和同步的机制，特别是利用缓冲区进行同步和通信的过程。通过补充新功能，使学生能灵活运用相关知识，培养创新能力。 2. 内容及要求： 1) 调试、运行模拟程序。 2) 发现并修改程序中不完善的地方。 3) 修改程序，使用随机数控制创建生产者和消费者的过程。 4) 在原来程序的基础上，加入缓冲区的写互斥控制功能，模拟多个进程存取一个公共缓冲区，当有进程正在写缓冲区时，其他要访问该缓冲区的进程必须等待，当有进程正在读取缓冲区时，其他要求读取的进程可以访问，而要求写的进程应该等待。 5) 完成1)、2)、3）功能的,得基本分,完成4)功能的加2分,有其它功能改进的再加2分 3. 程序说明： 　　本程序是模拟两个进程，生产者（producer）和消费者(Consumer)工作。生产者每次产生一个数据，送入缓冲区中。消费者每次从缓冲区中取走一个数据。缓冲区可以容纳8个数据。因为缓冲区是有限的，因此当其满了时生产者进程应该等待，而空时，消费者进程应该等待；当生产者向缓冲区放入了一个数据，应唤醒正在等待的消费者进程，同样，当消费者取走一个数据后，应唤醒正在等待的生产者进程。就是生产者和消费者之间的同步。 　　每次写入和读出数据时，都将读和写指针加一。当读写指针同样时，又一起退回起点。当写指针指向最后时，生产者就等待。当读指针为零时，再次要读取的消费者也应该等待。 为简单起见，每次产生的数据为0-99的整数，从0开始，顺序递增。两个进程的调度是通过运行者使用键盘来实现的。 4. 程序使用的数据结构 进程控制块：包括进程名，进程状态和执行次数。 缓冲区：一个整数数组。 缓冲区说明块：包括类型，读指针，写指针，读等待指针和写等待指针。 5. 程序使用说明 　　启动程序后，如果使用'p'键则运行一次生产者进程，使用'c'键则运行一次消费者进程。通过屏幕可以观察到两个进程的状态和缓冲区变化的情况。
利用记录型信号量机制： wait(s), signal(s)解决进程同步问题
Become hunger become strong
06-20 2万+
wait(s) 等价与Ｐ操作, signal(s)等价于V操作生产者－消费者问题int in = 0, out = 0; item buffer[n]; semaphore mutex = 1, empty = n, full = 0; void procuder() { do { procuder an item nextp; ... wait(empty)
信号量解决生产者消费者问题
l_ethan的博客
07-27 1983
用户进程可以通过操作系统提供的一对原语来对信号量进行操作，从而很方便的实现了进程互斥、进程同步。信号量是一个变量来表示系统中某种资源的数量。原语是一种特殊的程序段，其执行只能一气呵成，不可被中断。p、v操作p1.s-12.s-1>=0进程继续执行3.s-10进程继续执行3.s+1...
采用信号量法解决生产者消费者问题
09-20
采用信号量法解决生产者消费者问题代码及说明性文字
利用信号量机制实现生产者消费者问题
maybeth的博客
06-01 1万+
信号量 信号量机制主要用于实现进程间的同步，避免并发访问共享资源 函数 （一）获取或创建信号量 int semget(key_t key,int nsems,int semflg) key：信号量标识 nsems：信号量数量，若新创建信号量：nsems>0，若打开已有的信号量：nsems可为0 semflg：存取权限或创建方式，为IPC_CREAT：若信号量不存在，则创建一个信号量，否则获取...
信号量与生产者消费者问题
热门推荐
Hopefully Sky的博客
01-19 4万+
生产者—消费者问题 生产者—消费者题型在各类考试（考研、程序员证书、程序员面试笔试、期末考试）很常见，原因之一是生产者—消费者题型在实际的并发程序（多进程、多线程）设计中很常见；之二是这种题型综合性较好，涉及进程合作、互斥，有时还涉及死锁的避免。生产者—消费者题型可以全面考核你对并发程序的理解和设计能力。 生产者—消费者题型最基本的是有界缓冲区的生产者消费者问题和无界缓冲区的生产者消费者
信号量实现生产者消费者问题
weixin_44537258的博客
12-22 4120
生产者/消费者问题是一个多进程进行同步的问题，需要使用信号量（semaphore）进行相关资源的控制，实现并发。一些关于并发的基础概念如下： 原子操作 一组不可分割的函数或操作。这类函数或操作的执行是不可以被中断的。 临界区 进程中一段需要访问共享资源的代码，共享资源一次只能允许一个进程访问，系统要保证进入临界区的进程不超过一个。 正常执行可以并行，临界区代码执行只能串行。 解决并发问题的核心：控制对共享资源的访问 信号量（semaphore） 用于在进程间发送信号的整形变量，该变量定义3个原子操.
信号量实现生产者消费者
weixin_61631200的博客
05-08 459
我们用条件变量和互斥量实现了生产者消费者之后，也可以试试用信号量。甚至会更加简单。 可能大家对信号量还比较陌生 1.介绍信号量 信号量与互斥量 信号量相当于初始化值为N的互斥量。 互斥量保护了共享数据，但也使并行的线程变成串行，执行效率变低了。 互斥量一次只有一个线程可以访问公共区域，信号量可以同时有N个线程访问共享数据 信号量与信号：信号量（semaphore）和信号（signal）无关，完全是两回事。O(∩_∩)O哈哈~ 信号量不只能用于线程中，也可以用于进程间同步。 2.函数用法
以记录型信号量实现生产者-消费者问题
05-21
以记录型信号量实现生产者-消费者问题 实验目的： 1.加深对进程同步概念的理解。 2.理解多道程序环境中，不同进程对资源访问及相互合作进程的关系的处理方法。 实验要求： 利用C语言程序模拟生产者-消费者问题和哲学家进餐问题。 实验设备及环境： Pc机一台，vc6.0 for windows 实验步骤： 1.以记录型信号量实现生产者-消费者问题； 2.利用AND信号量解决生产者-消费者问题； 3.利用记录型信号量解决哲学家进餐问题 4.实验总结。
利用记录型信号量解决生产者-消费者问题
01-19
1.利用记录型信号量解决生产者-消费者问题.odt1.利用记录型信号量解决生产者-消费者问题.odt1.利用记录型信号量解决生产者-消费者问题.odt
基于 C语言 生产者消费者问题【100010806】
02-14
使用进程模拟消费者生产者进程，掌握进程之间的通信方法，区分在不同操作系统下进程通信的不同之处，并熟练使用信号量的创建删除等一系列操作 实验内容 一个大小为 3 的缓冲区，初始为空个生产者 随机等待一段时间...
操作系统实验：进程通信与进程同步（CTGU）
最新发布
11-23
(1)编写程序，使用Linux操作系统中的信号量机制模拟实现生产者-消费者问题。设有一个生产者和一个消费者，缓冲区可以存放产品，生产者不断生成产品放入缓冲区，消费者不断从缓冲区中取出产品，消费产品。
Python中的进程间通信
12-20
Python中的进程间通信 文章目录Python中的进程间通信1 进程间通信1.1 概念1.2进程间...为什么要使用生产者消费者模型2.什么是生产者和消费者模型3.生产者和消费者模型实现 1 进程间通信 1.1 概念 进程是操作系统分配
经典进程同步问题一：生产者-消费者问题(The producer-consumer problem)
dengduan2749的博客
05-11 3107
（注：参考教材：计算机操作系统第四版 西安电子科技大学出版社） 问题描述：一群生产者进程在生产产品，并将这些产品提供给消费者去消费。为了使生产者进程与消费者进程能够并发进行，在两者之间设置一个具有n个缓冲区的缓冲池，生产者进程将产品放入一个缓冲区中；消费者可以从一个缓冲区取走产品去消费。尽管所有的生产者进程和消费者进程是以异方式运行，但它们必须保持同步：当一个缓冲区为空时不...
Linux学习之系统编程篇：使用信号量实现“生产者和消费者模型”
weixin_42374938的博客
07-30 978
模型中，最为关键的步骤是，在生产者回调函数中，未生产之前，消费者回调函数是阻塞的，阻塞方式是条件变量。 那么不使用条件变量，如何使用“信号量”实现阻塞呢？ 答案是因为调用 sem_wait，当 sem == 0 时候，该线程就会阻塞。因此：生产者对应一个信号量 ：sem_t produce；消费者对应一个信号量 ：sem_t customer。 sem_init(&produce, 0, 2); sem_init(&customer, 0, 0); 消费者 value = 0，表示被阻塞
操作系统——信号量方法——生产者和消费者问题
mantou_riji的博客
11-23 2156
1.问题描述 有一群生产者进程在生产产品，并将这些产品提供给消费者进程去消费。 为使生产者进程与消费者进程能并发执行，在两者之间设置了一个具有n个缓冲区的缓冲池，生产者进程将它所生产的产品放入一个缓冲区中； 消费者进程可从一个缓冲区中取走产品去消费。 2.存储结构 缓冲池中有很多缓冲区，数据存放在缓冲区 缓冲区： 3.执行方法： 4.变量分析： （1）指针 由于这里的缓冲池是组织成循环缓冲的，故应把输入指针加1表示成 in∶=(in+1)mod n；输出指针加1表示成out∶=(out+1) mo
经典进程同步问题——生产者消费者（多生产者多消费者）
拿头去拼啊
11-10 4273
生产者-消费者问题 问题描述：一组生产者进程和一组消费者进程共享一个初始为空、大小为n的缓冲区，只有缓冲区没有满的时候，生产者才能把消息放入缓冲区，否则得等待缓冲区空闲出来；只有缓冲区不空的时，消费者才能从缓冲区取出消息，否则必须等待。由于缓冲区是临界资源，它只允许一个生产者放入消息，或一个消费者取出消息。 问题分析： 关系分析。生产者消费者是互斥关系，同时它们也是相互协作的关系，只有生产者生产了，消费者才能消费，它们也是同步关系。 整理思路。只有生产者和消费者两个进程，正好这两个是互斥和同步的关系
linux下实现信号量机制模拟实现生产者-消费者问题
05-10
在Linux下，可以使用系统提供的信号量机制来实现生产者-消费者问题。下面是一个简单的示例： ```c #include #include #include #include #include #define MAX_BUFFER_SIZE 10 // 缓冲区最大容量 #define ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值