Linux下利用信号量函数和共享内存函数和C语言实现生产者消费者问题

最新推荐文章于 2024-02-25 18:28:14 发布

modi000

最新推荐文章于 2024-02-25 18:28:14 发布

阅读量1.7k

点赞数

分类专栏： linux系统编程文章标签： linux

原文链接：https://blog.csdn.net/qq_31490151/article/details/78984593

版权

linux系统编程专栏收录该内容

72 篇文章 18 订阅

订阅专栏

接上一篇文章

一、引言

此问题是操作系统中的一个经典的同步异步问题，是我们操作系统课程中非常重要的一部分。实验要求我们用C语言在Linux操作系统下利用信号量函数和共享内存函数实现经典的生产者消费者问题。也借此博客把所学知识记录下来。实验要求如下：

在Linux操作系统下用C实现经典同步问题:生产者—消费者，具体要求如下:

（1）一个大小为10的缓冲区，初始状态为空。

（2）2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。

（3）2个消费者，随机等待一段时间，往缓冲区中读取数据，若缓冲区为空，等待生产者添加数据之后再读取，重复10次。

（4）当前只能有一个进程对这个缓冲区进行操作。

（5）缓冲区采用循环队列表示，利用头、尾指针来存放、读取数据，以及判断队列是否为空。缓冲区中数组大小为10。

（6）利用随机函数rand()得到A~Z的一个随机字符，作为生产者每次生产的数据，存放到缓冲区中。

（7）使用shmget()系统调用实现共享主存段的创建，shmget()返回共享内存区的ID。对于已经申请到的共享段，进程需把它附加到自己的虚拟空间中才能对其进行读写。

（8）信号量的建立采用semget()函数，同时建立信号量的数量。在信号量建立后，调用semctl()对信号量进行初始化，例如本实验中，可以建立两个信号量SEM_EMPTY、 SEM_FULL，初始化时设置SEM_EMPTY为10，SEM_FULL 为0。使用操作信号的函数semop()做排除式操作，使用这个函数防止对共享内存的同时操作。对共享内存操作完毕后采用shmctl()函数撤销共享内存段。

（9）使用循环，创建2个生产者以及2个消费者，采用函数 fork()创建一个新的进程。

（10）一个进程的一次操作完成后，采用函数fflush()刷新缓冲区。

（11）程序最后使用semctl()函数释放内存。

二、生产者消费者问题

生产者和消费者问题是多个相互合作的进程之间的一种抽象。生产者和消费者之间的关系:
1. 对缓冲区的访问是互斥的。由于两者都会修改缓冲区，因此，一方修改缓冲区时，另一方不能修改，这就是互斥。
2. 一方的行为影响另一方。缓冲区不空，才能消费，何时不空？生产了就不空；缓冲区满，就不能生产，何时不满？消费了就不满。这是同步关系。
为了描述这种关系，一方面，使用共享内存代表缓冲区；另一方面，使用互斥信号量控制对缓冲区的访问，使用同步信号量描述两者的依赖关系。

三、信号量

抽象的来讲，信号量（signal)的特性如下：信号量是一个非负整数，所有通过它的线程/进程都会将该整数减一（通过它当然是为了使用资源），当该整数值为零时，所有试图通过它的线程都将处于等待状态。在信号量上我们定义两种操作： Wait（等待）和 Release（释放）。当一个线程调用Wait操作时，它要么得到资源然后将信号量减一，要么一直等下去（指放入阻塞队列），直到信号量大于等于一时。Release（释放）实际上是在信号量上执行加操作，对应于车辆离开停车场，该操作之所以叫做“释放”是因为释放了由信号量守护的资源。在通用术语上我们将此两种操作成为P、V操作。而操作的对象就是信号量（signal)，用来实现线程/进程的同步、异步和互斥。

四、共享内存函数

共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。下面的表格列出了这四个函数的函数原型及其具体说明。

1. shmget函数原型

在Linux环境中，对开始申请的共享内存空间进行了初始化，初始值为0x00。

如果用shmget创建了一个新的消息队列对象时，则shmid_ds结构成员变量的值设置如下：

shm_lpid、shm_nattach、shm_atime、shm_dtime设置为0。

msg_ctime设置为当前时间。

shm_segsz设成创建共享内存的大小。

shmflg的读写权限放在shm_perm.mode中。

shm_perm结构的uid和cuid成员被设置成当前进程的有效用户ID，gid和cuid成员被设置成当前进程的有效组ID。

2. shmat函数原型

3. shmdt函数原型

4. shmctl函数原型

四、信号量函数

信号量函数由semget、semop、semctl三个函数组成。下面的表格列出了这三个函数的函数原型及具体说明。

1. semget函数原型

如果用semget创建了一个新的信号量集对象时，则semid_ds结构成员变量的值设置如下：

sem_otime设置为0。

sem_ctime设置为当前时间。

msg_qbytes设成系统的限制值。

sem_nsems设置为nsems参数的数值。

semflg的读写权限写入sem_perm.mode中。

sem_perm结构的uid和cuid成员被设置成当前进程的有效用户ID，gid和cuid成员被设置成当前进程的有效组ID。

2. semop函数原型

sops为指向sembuf数组，定义所要进行的操作序列。下面是信号量操作举例。

struct sembuf sem_get={0,-1,IPC_NOWAIT}; /*将信号量对象中序号为0的信号量减1*/

struct sembuf sem_get={0,1,IPC_NOWAIT}; /*将信号量对象中序号为0的信号量加1*/

struct sembuf sem_get={0,0,0}; /*进程被阻塞，直到对应的信号量值为0*/

flag一般为0，若flag包含IPC_NOWAIT，则该操作为非阻塞操作。若flag包含SEM_UNDO，则当进程退出的时候会还原该进程的信号量操作，这个标志在某些情况下是很有用的，比如某进程做了P操作得到资源，但还没来得及做V操作时就异常退出了，此时，其他进程就只能都阻塞在P操作上，于是造成了死锁。若采取SEM_UNDO标志，就可以避免因为进程异常退出而造成的死锁。

3. semctl函数原型

表15-4 semctl函数cmd形参说明表

五、 struct sembuf的部分讲解

struct sembuf  
{  
  unsigned short int sem_num;   /* 信号量的序号从0~nsems-1 */  
  short int sem_op;            /* 对信号量的操作，>0, 0, <0 */  
  short int sem_flg;            /* 操作标识：0， IPC_WAIT, SEM_UNDO */  
};

sem_num标识信号量集中的第几个信号量，0表示第1个，1表示第2个，nsems - 1表示最后一个。

sem_op标识对信号量的所进行的操作类型。对信号量的操作有三种类型：

sem_op > 0，对该信号量执行挂出操作，挂出的值由sem_op决定，系统会把sem_op的值加到该信号量的当前值semval（参考文章开头关于每个信号量结构的定义）上。如果sem_flag指定了SEM_UNDO（还原）标志，那么相应信号量的semadj值会减掉sem_op的值。下面会说明semadj的含义。
sem_op < 0，对该信号量执行等待操作，当信号量的当前值semval >= -sem_op时，semval减掉sem_op的绝对值，为该线程分配对应数目的资源。如果指定SEM_UNDO，相应信号量的semadj就加上sem_op的绝对值。当semval < -sem_op时，相应信号量的semncnt就加1，调用线程被阻塞，直到semval >= -sem_op，当此条件满足时，调用线程被唤醒，执行相应的分配操作，然后semncnt减去1.
sem_op = 0，表示调用者希望semval变为0。如果为0则立即返回，如果不为0，相应信号量的semzcnt加1，调用调用线程被阻塞。
sem_flag：信号量操作的属性标志，如果为0，表示正常操作，如果为IPC_WAIT，使对信号量的操作时非阻塞的。即指定了该标志，调用线程在信号量的值不满足条件的情况下不会被阻塞，而是直接返回-1，并将errno设置为EAGAIN。如果为SEM_UNDO，那么将维护进程对信号量的调整值，以便进程结束时恢复信号量的状态。

下面解释一下与单个信号量相关的几个值：

semval：信号量的当前值，在文章开头信号量的结构中已提到。

semncnt：等待semval变为大于当前值的线程数。在文章开头信号量的结构中已提到。

semzcnt：等待semval变为0的线程数。在文章开头信号量的结构中已提到。

semadj：指定信号量针对某个特定进程的调整值。只有sembuf结构的sem_flag指定为SEM_UNDO后，semadj才会随着sem_op而更新。讲简单一点：对某个进程，在指定SEM_UNDO后，对信号量semval值的修改都会反应到semadj上，当该进程终止的时候，内核会根据semadj的值，重新恢复信号量之前的值。

六、本次实验代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/types.h>
 
#define MAX_BUFFER_SIZE 10
#define SHM_MODE 0600
#define SEM_MODE 0600
 
#define SEM_FULL 0
#define SEM_EMPTY 1
#define MUTEX 2
/*
#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
//	 union   semun   is   defined   by   including   <sys/sem.h>   
#else 
//   according   to   X/OPEN   we   have   to   define   it   ourselves  
union semun{
	int val;
	struct semid_ds *buf;
	unsigned short *array;
};
#endif
union semun su;//sem union，用于初始化信号量
*/
 
struct my_buffer
{
	int head;
	int tail;
	char str[MAX_BUFFER_SIZE];
	int num;  //缓冲区里字母数量
	int is_empty;
};
 
const int N_CONSUMER = 2;//消费者数量
const int N_PRODUCER = 2;//生产者数量
const int N_BUFFER = 10;//缓冲区容量
const int N_WORKTIME = 10;//工作次数
int shm_id = -1;
int sem_id = -1;
pid_t child;
pid_t parent;
 
//得到10以内的一个随机数  
int get_random()  
{  
    int digit;  
    srand((unsigned)(getpid() + time(NULL)));  
    digit = rand() % 10;  
    return digit;  
}  
 
//得到A～Z的一个随机字母  
char getRandChar()
{
    char letter;  
    srand((unsigned)(getpid() + time(NULL)));  
    letter = (char)((rand() % 26) + 'A');  
    return letter;  
}
 
//sem_id 表示信号量集合的 id
//sem_num 表示要处理的信号量在信号量集合中的索引
//P操作
void waitSem(int sem_id,int sem_num)
{
	struct sembuf sb;
	sb.sem_num = sem_num;
	sb.sem_op = -1;//表示要把信号量减一
	sb.sem_flg = SEM_UNDO;//
	//第二个参数是 sembuf [] 类型的，表示数组
	//第三个参数表示 第二个参数代表的数组的大小
	if(semop(sem_id,&sb,1) < 0){
		perror("waitSem failed");
		exit(1);
	}
}
 
//V操作
void sigSem(int sem_id,int sem_num)
{
	struct sembuf sb;
	sb.sem_num = sem_num;
	sb.sem_op = 1;
	sb.sem_flg = SEM_UNDO;
	//第二个参数是 sembuf [] 类型的，表示数组
	//第三个参数表示 第二个参数代表的数组的大小
	if(semop(sem_id,&sb,1) < 0){
		perror("sigSem failed");
		exit(1);
	}
}
 
//打印进程运行结果
void printTime()
{
	//打印时间
	time_t now;
	struct tm *timenow;         //实例化tm结构指针
	time(&now);
	timenow = localtime(&now);
	printf("执行时间： %s ",asctime(timenow));
}
 
int main(int argc, char ** argv)
{
	shm_id = shmget(IPC_PRIVATE,MAX_BUFFER_SIZE,SHM_MODE);   //申请共享内存
	if(shm_id < 0)
	{
		perror("create shared memory failed");
		exit(1);
	}
 
	struct my_buffer *shmptr;  
	shmptr = shmat(shm_id, 0, 0);   //将申请的共享内存附加到申请通信的进程空间
	if (shmptr == (void*)-1)
	{  
        perror("add buffer to using process space failed！\n");  
        exit(1);  
    }  
 
	if((sem_id = semget(IPC_PRIVATE,3,SEM_MODE)) < 0)
	{                  								//创建三个信号量，SEM_EMPTY,SEM_FULL和MUTEX
		perror("create semaphore failed! \n");
		exit(1);
	}
 
	if(semctl(sem_id,SEM_FULL,SETVAL,0) == -1)
	{												//将索引为0的信号量设置为0-->SEM_FULL
		perror("sem set value error! \n");		
		exit(1);
	}
 
	if(semctl(sem_id,SEM_EMPTY,SETVAL,10) == -1)
	{												//将索引为1的信号量设置为10-->SEM_EMPTY
	 	perror("sem set value error! \n");
	 	exit(1);
	}
	if(semctl(sem_id,MUTEX,SETVAL,1) == -1)
	{												//将索引为3的信号量设置为1-->MUTEX
	 	perror("sem set value error! \n");
	 	exit(1);
	}
 
	shmptr -> head = 0;  
    shmptr -> tail = 0;  
    shmptr -> is_empty = 1;  
    shmptr -> num = 0;
 
	for(int i = 0; i < N_PRODUCER; i++)
	{
		parent = fork();
		if(parent < 0)
		{
			perror("the fork failed");
			exit(1);
		}
		else if(parent == 0)
		{
			shmptr = shmat(shm_id, 0, 0);   //将申请的共享内存附加到申请通信的进程空间
			if (shmptr == (void*)-1)
			{  
        		perror("add buffer to using process space failed！\n");  
        		exit(1);  
    		}  
			int count = 0;
			for(int j = 0; j < N_WORKTIME; j++)
			{
				waitSem(sem_id, SEM_EMPTY);
				waitSem(sem_id, MUTEX);
				sleep(get_random()); 
 
				printf("-------------------------------------------------------------\n");
				printf("我是第 %d 个生产者进程，PID = %d\n", i + 1, getpid());
 
				/*生产产品*/
				char c = getRandChar();                                      //随机获取字母
				shmptr -> str[shmptr->tail] = c;
                shmptr -> tail = (shmptr->tail + 1) % MAX_BUFFER_SIZE;  
                shmptr -> is_empty = 0;           //写入新产品  
				shmptr -> num++;
 
				/*打印输出结果*/
				printTime();              //程序运行时间
 
				int p;
				printf("缓冲区数据（%d个）：",shmptr -> num);                   //打印缓冲区中的数据
				p = (shmptr->tail-1 >= shmptr->head) ? (shmptr->tail-1) : (shmptr->tail-1 + MAX_BUFFER_SIZE);  
                for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--)  
                {  
                    printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);  
                }  
                printf("\t 生产者 %d  放入 '%c'. \n", i + 1, c);  
				printf("-------------------------------------------------------------\n");
 
				fflush(stdout);
				sigSem(sem_id, MUTEX);
				sigSem(sem_id, SEM_FULL);
			}
			//将共享段与进程之间解除连接  
            shmdt(shmptr);  
            exit(0); 
		} 
	}
 
	for(int i = 0; i < N_CONSUMER; i++)
	{
		child = fork();
		if(child < 0)//调用fork失败
		{
			perror("the fork failed");
			exit(1);
		}
		else if(child == 0)
		{
			int count = 0; 
			shmptr = shmat(shm_id, 0, 0);   //将申请的共享内存附加到申请通信的进程空间
			if (shmptr == (void*)-1)
			{  
        		perror("add buffer to using process space failed！\n");  
        		exit(1);  
    		} 
			for(int j = 0; j < N_WORKTIME; j++)
			{
 
				waitSem(sem_id, SEM_FULL);
				waitSem(sem_id, MUTEX);
				sleep(get_random()); 
 
				printf("-------------------------------------------------------------\n");
				printf("我是第 %d 个消费者进程，PID = %d\n", i + 1, getpid());
				/*消费数据*/
				char lt = shmptr -> str[shmptr -> head];  
                shmptr -> head = (shmptr -> head + 1) % MAX_BUFFER_SIZE;  
                shmptr -> is_empty = (shmptr->head == shmptr->tail);  //
				shmptr -> num--;
				/*打印输出结果*/
				printTime(); //程序运行时间
 
				int p;
				printf("缓冲区数据（%d个）：",shmptr -> num);                   //打印缓冲区中的数据
				p = (shmptr -> tail - 1 >= shmptr -> head) ? (shmptr -> tail-1) : (shmptr -> tail - 1 + MAX_BUFFER_SIZE);  
                for (p; !(shmptr -> is_empty) && p >= shmptr -> head; p--)  
                {  
                    printf("%c", shmptr -> str[p % MAX_BUFFER_SIZE]);  
                }  
                printf("\t 消费者 %d  取出 '%c'. \n", i + 1, lt);  
				printf("-------------------------------------------------------------\n");
 
				fflush(stdout);
				sigSem(sem_id,MUTEX);
				sigSem(sem_id,SEM_EMPTY);
			}
			//将共享段与进程之间解除连接  
        	shmdt(shmptr);  
        	exit(0);
		}  
	}
 
	    //主进程最后退出  
    while (wait(0) != -1);  
    //将共享段与进程之间解除连接  
    shmdt(shmptr);  
    //对共享内存区执行控制操作  
    shmctl(shm_id,IPC_RMID,0);//当cmd为IPC_RMID时，删除该共享段  
    shmctl(sem_id,IPC_RMID,0);  
    printf("主进程运行结束！\n");  
    fflush(stdout);  
    exit(0); 
	return 0;
}

————————————————
版权声明：本文为CSDN博主「暮雪繁香」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_31490151/article/details/78984593

modi000

关注

0
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
Linux下利用信号量函数和共享内存函数和C语言实现生产者消费者问题

接上一篇文章一、引言此问题是操作系统中的一个经典的同步异步问题，是我们操作系统课程中非常重要的一部分。实验要求我们用C语言在Linux操作系统下利用信号量函数和共享内存函数实现经典的生产者消费者问题。也借此博客把所学知识记录下来。实验要求如下：在Linux操作系统下用C实现经典同步问题:生产者—消费者，具体要求如下:（1）一个大小为10的缓冲区，初始状态为空。（2）2个生产者，随机等待一段时间，往缓冲区中添加数据，若缓冲区已满，等待消费者取走数据之后再添加，重复10次。（3）2.
复制链接

扫一扫