linux系统中的进程通信（消息队列、共享内存、信号量）

最新推荐文章于 2023-02-26 23:37:58 发布

c1194758555

最新推荐文章于 2023-02-26 23:37:58 发布

阅读量654

点赞数

分类专栏： linux应用程序设计文章标签：信号量共享内存消息队列

本文链接：https://blog.csdn.net/c1194758555/article/details/52513890

版权

linux应用程序设计专栏收录该内容

17 篇文章 0 订阅

订阅专栏

消息队列：类似与管道只能单项通信，消息队列由消息组成，消息可以有不同的数据结构，也可以由有优先级，能够更加灵活的通信。消息队列使用int msgget(key_t key,int flags)获得或创建消息队列，使用void msgsnd(int msqid,const void *msgp,size_t msgsz,int msgflg);发送消息，使用size_t msgrcv(int msqid,void *msgp,size_t msgz,long int msgtype,int msgflg);接收消息，通过int msgctl(int msqid,int cmd,struct msgid_ds *buf); 查询、获取、删除消息队列。

#include <sys/msg.h>
int msgget(key_t key,int flags);

key：消息对列的关键字。

flags：访问权限，创建标志（IPC_CREAT、IPC_EXCL）

#include <sys/msg.h>
void msgsnd(int msqid,const struct void *msgp,size_t msgsz,int msgflg);

msqid：IPC描述字。

msgp：消息缓存区指针。

ｍsgsz：消息缓存去正文的大小。

msgflg:控制变量（IPC_NOWAIT，MSG_NOERROR）

＃include <sys/msg.h>
size_t msgrcv(int msqid,void *msgp,size_t msgz,long int msgtype,int msgflg);

msqid：IPC描述字。

msgp：消息缓存区指针。

ｍsgsz：消息缓存去正文的大小。

msgype：消息的接收类型。

msgype = 0 按顺序接收。

msgype < 0 接收特定的消息

msgype > 0 按优先级接收

msgflg:控制变量（IPC_NOWAIT，MSG_NOERROR）

#include <sys.msg.h>
int msgctl(int msqid,int cmd,struct msgid_ds *buf);

msqid:　IPC描述字

cmd:　执行的命令

msgsz:　指向msqid_ds

接收：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/msg.h>
#include <errno.h>
#define BUFSIZE 1024

struct my_msg /*消息数据类型*/
{
	long int mtype;
	char mtext[BUFSIZE];
};

int main()
{
	int msgid;
	struct my_msg my;

	if((msgid = msgget(565,0666|IPC_CREAT)) == -1)　/*创建或获取消息队列*/
　	{
		fprintf(stderr,"msg faile!\n");
		exit(1);
	}
	while(1)
	{
		if(msgrcv(msgid,&my,sizeof(struct my_msg),-57,IPC_NOWAIT) != -1)　/*接收优先级小于57的消息*/
			fprintf(stdout,"%s\n",my.mtext);
		else if(errno == ENOMSG && msgrcv(msgid,&my,sizeof(struct my_msg),0,0) != -1)　/*按顺序接收消息*/
			fprintf(stdout,"%s\n",my.mtext);
		else
		{
			fprintf(stderr,"fiale!\n");
			exit(1);
		}

		if(!strncmp(my.mtext,"end",3))
			break;
	}
	if(msgctl(msgid,IPC_RMID,NULL) == -1)　/*删除消息队列*/
	{
		fprintf(stderr,"rm faile\n");
		exit(1);
	}
	exit(0);
}

发送：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/msg.h>
#include <errno.h>
#define BUFSIZE 1024

struct my_msg /*消息的数据类型*/
{
	long int mtype;
	char mtext[BUFSIZE];
};

int main()
{
	int msgid;
	struct my_msg my;

	if((msgid = msgget(565,0666|IPC_CREAT)) == -1)　/*创建或获取消息队列*/
	{
		fprintf(stderr,"msg faile!\n");
		exit(1);
	}
	while(1)
	{
		fprintf(stdout,"Plase Input\n");
		fgets(my.mtext,BUFSIZE,stdin);
		my.mtype = my.mtext[0];

		if(msgsnd(msgid,&my,sizeof(struct my_msg),IPC_NOWAIT) == -1)　/*发送消息*/
		{
			fprintf(stderr,"msgsd faild!\n");
			exit(1);
		}
		if(!strncmp(my.mtext,"end",3))
			break;
	}
	exit(0);
}

共享内存：多个进程能够连接到同一个内存区域，都能够对其进行读取操作。通过int shmget(key_t key,size_t size,int shmflg);创建或者获取共享内存，通过void *shmat(int shmid,const void *shmaddr,int shmflg);链接到共享内存，通过int shmdt(int shmid,void *shmaddr);取消对共享内存的链接，通过int shmctl(int shmid,int cmd,struct shmid_ds *buf);查询、设置、删除，共享内存。

#include <sys/shm.h>
int shmget(key_t key,size_t size,int shmflg);

key:　IPC关键字

size:　共享内存大小

shmflg:　访问控制标志

#include <sys/shm.h>
void *shmat(int shmid,const void *shmaddr,int shmflg);

shmid：　IPC描述字

shmadrr：共享内存地址

shmflg：控制变量

#include <sys/shm.h>
int shmdt(int shmid,void *shmaddr);

shmid：　IPC描述字

shmadrr：共享内存地址

#include <sys/shm.h>
int shmctl(int shmid,int cmd,struct shmid_ds *buf);

shmid: IPC描述字

cmd: 命令

buf: 指向shmid_ds

创建共享内存并写入数据：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/shm.h>
#define Size 1024


int main()
{
	int shmId;
	char *s,*shm;

	if((shmId = shmget(565,Size,0666|IPC_CREAT)) == -1) /*创建或获取共享内存*/
	{
		fprintf(stderr,"shm fail\n");
		exit(0);
	}

	if((shm = shmat(shmId,NULL,0)) == -1) /*链接到共享内存*/
	{
		fprintf(stderr,"make faile!\n");
		exit(1);
	}
	s = shm;

	char i;
	for(i = 'A'; i <= 'Z'; i++) /*向共享内存写入数据*/
		*s++ = i;
	*s = 0;
	exit(0);
}

读取共享内存：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/shm.h>
#define Size 1024


int main()
{
	int shmId;
	char *s,*shm;

	if((shmId = shmget(565,Size,0666)) == -1) /*获取或创建共享内存*/
	{
		fprintf(stderr,"shm fail\n");
		exit(0);
	}
	if((shm = shmat(shmId,NULL,0)) == (char*)-1) /*链接到共享内存*/
	{
		fprintf(stderr,"shmId faild\n");
		exit(1);
	}

	s = shm;
	fprintf(stdout,"%s\n",s);

	exit(0);
}

信号量：信号量可以解决消息队列、共享内存的竞争情况。信号量主要用于互斥情形和生产消费情形。可以通过int semget(key_t key,int nsems,int semflg);获取或创建信号量，通过int semop(int semid,struct sembuf *sops,size_t nsops);操作信号量，通过int semctl(int semid,int semnum,int cmd,[union semun arg]);查询、删除、设置信号量。

生产消费问题，创建一个生产者、消费者都能访问的共享内存。建立两个信号量保证两个进程的互斥访问，sem_pu_ok生产者进程没有访问共享内存，sem_con_ok消费者内存没有访问共享内存。具体代码如下：

生产者：

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/unistd.h>
#include <sys/fcntl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define key_pu 1024
#define key_con 1025
#define key_shm 2048
#define Max 1024
#define ERR(msg,f) { \
	if(f < 0) { \
		fprintf(stderr,"%s",msg); \
		exit(1); \
	} \
}

union semun {
int val;
struct semid_ds *buf;
unsigned short  *array;
};

int get_sem(int key,int sems) /*设置信号量*/
{
	if(sems <= 0)
		ERR("create sem failed\n",sems - 1);

	int sem_id;
	sem_id = semget(key,sems, 0666 | IPC_CREAT);
	ERR("create sem failed\n",sem_id);

	return sem_id;
}

int get_shm(int shm_id,ssize_t size) /*设置共享内存*/
{
	if(size <= 0)
		ERR("shm create faile\n",size - 1);
	int shm;
	shm = shmget(shm_id,size,0666 | IPC_CREAT);
	ERR("shm create faile\n",shm);

	return shm;
}

void init_sem(int sem_id,int semnum,int init_num) /*初始化信号量*/
{
	union semun sem_set;
	sem_set.val = init_num;
	ERR("sem init failed\n",semctl(sem_id, semnum, SETVAL,sem_set));

	return;
}

char *get_shm_addr(int shm_id) /*把共享内存映射到进程空间*/
{
	char *addr = NULL;
	addr = shmat(shm_id, NULL, 0);
	if(addr)
		return addr;
	ERR("at shm faile\n",-1);
}

void sem_p(int sem_id) /*P操作*/
{
	struct sembuf buf;
	buf.sem_op = -1;
	buf.sem_flg = 0;
	buf.sem_flg = SEM_UNDO;

 	ERR("sem p faile\n",semop(sem_id, &buf, 1));

 	return;
}

void sem_v(int sem_id) /*V操作*/
{
	struct sembuf buf;
	buf.sem_op = 1;
	buf.sem_flg = 0;
	buf.sem_flg = SEM_UNDO;

 	ERR("sem p faile\n",semop(sem_id, &buf, 1));

 	return;
}

void rm_sem(int sem_id) /*删除信号量*/
{
	ERR("delete sem failed\n",semctl(sem_id, 0, IPC_RMID,0));
	return;
}

struct info{ /*共享内存数据类型*/
	char buf[Max];
	int g;
};

int main(int argc,char *argv[])
{
	int shm_id,sem_pu_ok,sem_con_ok;
	struct info  *shm_addr = NULL;

	sem_pu_ok = get_sem(key_pu,1); /*获得信号量*/
	sem_con_ok = get_sem(key_con,1); /*获得信号量*/

	init_sem(sem_con_ok,0,1); /*初始化信号量*/
	init_sem(sem_pu_ok,0,0); /*初始化信号量*/

	shm_id = get_shm(key_shm,sizeof(struct info)); /*建立共享存储*/
	shm_addr = (struct info*)get_shm_addr(shm_id); /*把共享内存映射到进程地址空间*/

	int i;
	for(i = 0;;i++){
		sem_p(sem_con_ok); /*P操作*/

		printf("palse input string:\n");
		fgets(shm_addr->buf, Max, stdin);
		shm_addr->g = i;

		sem_v(sem_pu_ok); /*V操作*/
		if(!strncmp(shm_addr->buf,"end",3)) /*若是end结束*/
			break;
	}
	sem_p(sem_con_ok); /*等待消费进程完成*/

	rm_sem(sem_con_ok); /*删除信号量*/
	rm_sem(sem_pu_ok); /*删除信号量*/
	shmdt(shm_addr); /*分离共享内存*/
	shmctl(shm_id,IPC_RMID,0); /*删除共享内存*/

	exit(0);
}

消费者进程：

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/unistd.h>
#include <sys/fcntl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#define key_pu 1024
#define key_con 1025
#define key_shm 2048
#define Max 1024
#define ERR(msg,f) { \
	if(f < 0) { \
		fprintf(stderr,"%s",msg); \
		exit(1); \
	} \
}

union semun {
int val;
struct semid_ds *buf;
unsigned short  *array;
};

int get_sem(int key,int sems)
{
	if(sems <= 0)
		ERR("create sem failed\n",sems - 1);

	int sem_id;
	sem_id = semget(key,sems, 0666 | IPC_CREAT);
	ERR("create sem failed\n",sem_id);

	return sem_id;
}

int get_shm(int shm_id,ssize_t size)
{
	if(size <= 0)
		ERR("shm create faile\n",size - 1);
	int shm;
	shm = shmget(shm_id,size,0666 | IPC_CREAT);
	ERR("shm create faile\n",shm);

	return shm;
}

void init_sem(int sem_id,int semnum,int init_num)
{
	//union semun sem_set;
	union semun sem_set;
	sem_set.val = init_num;
	ERR("sem init failed\n",semctl(sem_id, semnum, SETVAL,sem_set));

	return;
}

char *get_shm_addr(int shm_id)
{
	char *addr = NULL;
	addr = shmat(shm_id, NULL, 0);
	if(addr)
		return addr;
	ERR("at shm faile\n",-1);
}

void sem_p(int sem_id)
{
	struct sembuf buf;
	buf.sem_op = -1;
	buf.sem_num = 0;
	buf.sem_flg = SEM_UNDO;

 	ERR("sem p faile\n",semop(sem_id, &buf, 1));

 	return;
}

void sem_v(int sem_id)
{
	struct sembuf buf;
	buf.sem_op = 1;
	buf.sem_num = 0;
	buf.sem_flg = SEM_UNDO;

 	ERR("sem p faile\n",semop(sem_id, &buf, 1));

 	return;
}

void rm_sem(int sem_id)
{
	ERR("delete sem failed\n",semctl(sem_id, 0, IPC_RMID,0));
	return;
}

struct info{
	char buf[Max];
	int g;
};

int main(int argc,char *argv[])
{
	int shm_id,sem_pu_ok,sem_con_ok;
	struct info  *shm_addr = NULL;

	sem_pu_ok = get_sem(key_pu,1);
	sem_con_ok = get_sem(key_con,1);

	shm_id = get_shm(key_shm,sizeof(struct info));
	shm_addr = (struct info*)get_shm_addr(shm_id);

	int i;
	for(i = 0;;i++){
		sem_p(sem_pu_ok);

		printf("pid is: %d NO:%d rcv data is:%s\n",getpid(),shm_addr->g,shm_addr->buf);

		sem_v(sem_con_ok);
		if(!strncmp(shm_addr->buf,"end",3))
			break;
	}

	shmdt(shm_addr);
	sem_v(sem_con_ok); /*唤醒生产者进程*/

	exit(0);
}

c1194758555

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
linux系统中的进程通信（消息队列、共享内存、信号量）

消息队列：类似与管道只能单项通信，消息队列由消息组成，消息可以有不同的数据结构，也可以由有优先级，能够更加灵活的通信。消息队列使用int msgget(key_t key,int flags)获得或创建消息队列，使用void msgsnd(int msqid,const void *msgp,size_t msgsz,int msgflg);发送消息，使用size_t msgrcv(int ms
复制链接

扫一扫