Linux系统编程_进程间通信_pipe memfd-优快云博客

本文链接：https://blog.youkuaiyun.com/chmod_a/article/details/128462608

本文详细介绍了Linux系统编程中的进程间通信方式，包括无名管道、命名管道、消息队列、共享内存和信号。无名管道适用于父子进程通信，命名管道可实现无关进程间通信。消息队列存储在内核中，可持久化数据。共享内存允许多个进程直接访问同一块内存，而信号量用于控制对共享内存的访问。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

IPC通信方式:管道（无名管道和命名管道）、消息队列、信号量、共享存储、socket、streams等（同PC内进程通信）；socket和streams支持不同PC间进程通信

一、管道：

半双工、父子间、只存在于内存

1.无名管道

int pipe(int fd[2]) //成功返回0 fd[0] 读打开 fd[1] 写打开
注意：wait()放在代码末
阻塞：当代码条件不满足时，无法往下执行

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main()
{
	int fd[2];

	int pid;

	char buf[128];

//	int pipe(int pipefd[2]);

	if(pipe(fd) == -1){
		printf("creat pipe failed\n");
	}
	pid = fork();
	
	if(pid<0){
		printf("creat child failed\n");
	}
	else if(pid > 0){
		sleep(3);
		printf("this is father\n");

		close(fd[0]);
		write(fd[1],"hello from father",strlen("hello form father"));
		wait();
	}else{
		printf("this is child\n");
		close(fd[1]);
		read(fd[0],buf,128);
		printf("read from father: %s\n",buf);
		exit(0);
	}
	

	return 0;
}

2.命名管道：存在于磁盘

1 #include <sys/stat.h>
2 // 返回值：成功返回0，出错返回-1
3 int mkfifo(const char *pathname, mode_t mode);

FIFO，也称为命名管道，它是一种文件类型。
1.FIFO可以在无关的进程之间交换数据，与无名管道不同。
2.FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中。

open() creat 文件权限 r:4 w:1 x:2

其中的 mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它。

当 open 一个FIFO时，是否设置非阻塞标志（O_NONBLOCK）的区别：

若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。
若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include<errno.h>
#include <fcntl.h>

//       int mkfifo(const char *pathname, mode_t mode);
int main()
{
	if( (mkfifo("./file",0600) == -1) && errno!=EEXIST){
		printf("mkfifo failuer\n");
		perror("why");
	}

	int fd = open("./file",O_RDONLY);
	printf("open success\n");


	return 0;
}

二、消息队列（存在于内核中）

有AB两个进程
系统上内核上有多个队列；所以尽管两个通信的进程结束了，消息也依然存在内核中
1.B如何加消息到队列，（将结构体加入到来链表中）
2.A如何读取队列的消息。AB使用同一队列才可通信
3.如何创建消息队列

// 创建或打开消息队列：成功返回队列ID，失败返回-1

int msgget(key_t key, int flag);

msgget(队列索引值（一个队列的身份），IPC_CREAT|0777（权限）（创建指定key值的队列）)

// 添加消息：成功返回0，失败返回-1

int msgsnd(int msqid, const void *ptr, size_t size, int flag);

// 读取消息：成功返回消息数据的长度，失败返回-1

int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);

// 控制消息队列：成功返回0，失败返回-1

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

读/写端的key、msgtyp (888)要相同才能通信
int flag == 0 是阻塞方式

两段代码同时运行，相互收发

添加消息：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
//函数原型
//       int msgget(key_t key, int msgflg);
//        int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
//                      int msgflg);
struct msgbuf {
               
	long mtype;       /* message type, must be > 0 */
        char mtext[256];    /* message data */
};


int main()
{
	//1.huoqu
	struct msgbuf readBuf;	


	key_t key;
	key = ftok(".",'m');
	printf("key=%x\n",key);

	int msgId = msgget(key, IPC_CREAT|0777);
	if(msgId == -1 ){
		printf("get que failuer\n");
	}
	memset(&readBuf,0,sizeof(struct msgbuf));

	msgrcv(msgId, &readBuf,sizeof(readBuf.mtext),888,0);	
	printf("read from que:%s\n",readBuf.mtext);

        struct msgbuf sendBuf = {988,"thank you for reach"};
        msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);

	msgctl(msgId,IPC_RMID,NULL);

	return 0;
}

获取消息：

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
//       int msgget(key_t key, int msgflg);
//        int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

//       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
//                      int msgflg);
struct msgbuf {
               
	long mtype;       /* message type, must be > 0 */
        char mtext[256];    /* message data */
};


int main()
{
	//1.huoqu
	struct msgbuf sendBuf = {888,"this is message from quen"};	
	struct msgbuf readBuf;

	memset(&readBuf,0,sizeof(struct msgbuf));
	key_t key;
        key = ftok(".",'m');
        printf("key=%x\n",key);

        int msgId = msgget(key, IPC_CREAT|0777);

	if(msgId == -1 ){
		printf("get que failuer\n");
	}
	
	msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
	printf("send over\n");

        msgrcv(msgId, &readBuf,sizeof(readBuf.mtext),988,0);
	printf("reaturn from get:%s\n",readBuf.mtext);
	
	msgctl(msgId,IPC_RMID,NULL);
	
	return 0;
}

注意：前三种通信方式数据都会保留，都是读出来，不会销毁

三、共享内存

（只是用共享内存会照成一个问题：就是当多个进程同时写入数据到一块共享内存的时候，会造成数据覆盖，后面引入信号量，错开写入）
不需要读出，一旦A进程写入数据，B进程立马可以操作数据

AB都可访问的内存空间

创建共享内存，打开/当只需要读取时获取即可，相同的key则共享内存地址相同，不需要创建
映射共享内存到A进程的内存/或B进程
数据交换
卸载映射
不使用时销毁内存

size 至少1M

1.//int shmget(key_t key, size_t size（最少1M）, int shmflg(IPC_CREAT)|0666）);
2.void *shmat(int shmid, const void *shmaddr（0，内核自动分配地址）, int shmflg（0，可读可写）);
3.//int shmdt(const void *shmaddr);
4.//int shmctl(int shmid, int cmd（0，默认关闭）, struct shmid_ds *buf(0,退出时不保存数据));

命令查看共享内存：ipcs -m
删除共享内存： ipcrm +(shmid)

读取端：（读取时将指针指向共享内存即可）

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//int shmget(key_t key, size_t size, int shmflg);
int main()
{
	
	int shmid;
	char *shmaddr;

	
	key_t key;
	key = ftok(".",1);
	
	shmid = shmget(key,1024*4,0);
	if(shmid == -1){
		printf("shmget noOk\n");
		exit(-1);
	}
	shmaddr = shmat(shmid,0,0);

	printf("shmat ok\n");
	printf("data: %s\n:",shmaddr);

	shmdt(shmaddr);

	printf("quit\n");
	
	return 0;
}

写入端

#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

//int shmget(key_t key, size_t size, int shmflg);
int main()
{
	
	int shmid;
	char *shmaddr;

	
	key_t key;
	key = ftok(".",1);
	
	shmid = shmget(key,1024*4,IPC_CREAT|0666);
	if(shmid == -1){
		printf("shmget noOk\n");
		exit(-1);
	}
	shmaddr = shmat(shmid,0,0);

	printf("shmat ok\n");
	strcpy(shmaddr,"chenlichen");

	sleep(5);
	shmdt(shmaddr);
	shmctl(shmid, IPC_RMID, 0);

	printf("quit\n");
	
	return 0;
}

四、信号

参考博文：https://www.jianshu.com/p/f445bfeea40a
类似于单片机的中断（也存在优先级）
kill -l 查看信号

每个信号都宏定义为一个正整数，但0信号特殊的

（信号初级编程）信号的处理：忽略，捕捉，默认动作

忽略：（SIGKILL 和 SIGSTOP不能被忽略）sighandler_t handler传入宏SIG_IGN即信号被忽略

typedef void (*sighandler_t)(int);／／声明这个类型的函数指针；处理信号的函数
sighandler_t signal(int signum, sighandler_t handler);／／信号注册函数，操作函数，

kill();-->发送信号

捕捉：由操作函数handler（）决定

注意：转换成整数的函数-->用处：main传参数时，传的是字符串，但需要以整数的形式调用；
int atoi(const char *nptr);

sprintf();-->
int sprintf(char *string, char *format [,argument,…]);
参数列表
string-- 这是指向一个字符数组的指针，该数组存储了 C 字符串。
format-- 这是字符串，包含了要被写入到字符串 str 的文本。它可以包含嵌入的 format 标签，format 标签可被随后的附加参数中指定的值替换，并按需求进行格式化。format 标签属性是%[flags][width][.precision][length]specifier
[argument]...：根据不同的 format 字符串，函数可能需要一系列的附加参数，每个参数包含了一个要被插入的值，替换了 format 参数中

system函数
system函数和exec函数一样，都是执行shell 命令，但是system比较顶，把execl函数封装起来，所以习惯上使用system函数
int system(const char *command); //（）是shell命令及参数
捕捉：

信号接收端

#include <signal.h>
#include <stdio.h>

//       typedef void (*sighandler_t)(int);

//       sighandler_t signal(int signum, sighandler_t handler);

void handler(int signum)
{
	printf("get signum=%d\n",signum);
	switch(signum){
		case 2:
			printf("SIGINT\n");
			break;
		case 9:
			printf("SIGKILL\n");
			break;
		case 10:
			printf("SIGUSR1\n");
			break;

	}




	printf("never quit\n");
}

int main()
{
	signal(SIGINT,SIG_IGN);
	signal(SIGKILL,SIG_IGN);
	signal(SIGUSR1,handler);
	while(1);
	return 0;
}

信号发送端

#include <signal.h>
#include <stdio.h>
#include <sys/types.h>


int main(int argc ,char **argv)
{
	int signum;
	int pid;

	char cmd[128]={0};

	signum = atoi(argv[1]);
	pid = atoi(argv[2]);

	printf("num=%d,pid=%d\n",signum,pid);	

//	kill(pid, signum);
	sprintf(cmd,"kill -%d %d",signum,pid);

	
	system(cmd);

	printf("send signal ok");	
	return 0;
}

信号高级编程：信号携带消息

一、发信号
1.用什么发
   sigqueqe();
2.怎么放入消息
二、收信号
1.用什么接收函数
   sigactoin();
       signum;
       struct sigaction *act;
           1.信号处理函数，不可携带数据，忽略SIG_IGN,默认SIG_DFL
           2.信号出库函数，可携带数据
           3.阻塞关键字
           4.影响信号的行为SA_SIGINFO表示能够接受数据

       struct sigaction *oldact;那么可以对之前的信号配置进行备份

2.如何读出消息

五、信号量（钥匙）:不发数据

进程竞争获取锁，当没有锁可获取到就机会阻塞在当前位置，总锁数由初始化时确定

临界资源，共享内存的一种，但是一个时刻只允许一个进程使用，如打印机
信号量集：多把钥匙
P操作：拿锁，锁-1
V操作：放回锁，锁+1

例程

#include<stdio.h>
#include<stdlib.h>
#include<sys/sem.h>


// 初始化信号量
//int semctl(int semid, int semnum, int cmd, ...);
int init_sem(int sem_id, int value)
{
	if(semctl(sem_id, 0, SETVAL) == -1)
	{
		perror("Init Semaphore Error");
		return -1;
	}
	return 0;
}

// P操作:
//    若信号量值为1，获取资源并将信号量值-1 
//    若信号量值为0，进程挂起等待
int sem_p(int sem_id)
{
	struct sembuf sbuf;
	sbuf.sem_num = 0; /*序号*/
	sbuf.sem_op = -1; /*P操作*/
	sbuf.sem_flg = SEM_UNDO;

	if(semop(sem_id, &sbuf, 1) == -1)
	{
		perror("P operation Error");
		return -1;
	}
	return 0;
}

// V操作：
//    释放资源并将信号量值+1
//    如果有进程正在挂起等待，则唤醒它们
int sem_v(int sem_id)
{
	struct sembuf sbuf;
	sbuf.sem_num = 0; /*序号*/
	sbuf.sem_op = 1;  /*V操作*/
	sbuf.sem_flg = SEM_UNDO;

	if(semop(sem_id, &sbuf, 1) == -1)
	{
		perror("V operation Error");
		return -1;
	}
	return 0;
}

// 删除信号量集
int del_sem(int sem_id)
{
	union semun tmp;
	if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
	{
		perror("Delete Semaphore Error");
		return -1;
	}
	return 0;
}


int main()
{
	int sem_id;  // 信号量集ID
	key_t key;  
	pid_t pid;

	// 获取key值
	if((key = ftok(".", 'z')) < 0)
	{
		perror("ftok error");
		exit(1);
	}

	// 创建信号量集，其中只有一个信号量
	if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
	{
		perror("semget error");
		exit(1);
	}

	// 初始化：初值设为0资源被占用
	init_sem(sem_id, 0);

	if((pid = fork()) == -1)
		perror("Fork Error");
	else if(pid == 0) /*子进程*/ 
	{
		sleep(2);
		printf("Process child: pid=%d\n", getpid());
		sem_v(sem_id);  /*释放资源*/
	}
	else  /*父进程*/
	{
		sem_p(sem_id);   /*等待资源*/
		printf("Process father: pid=%d\n", getpid());
		sem_v(sem_id);   /*释放资源*/
		del_sem(sem_id); /*删除信号量集*/
	}
	return 0;
}

注意：当使用IPC_CREAT时，需要｜权限，例如IPC_CREAT|0666

使用完后要销毁掉；
semctl(semid,0,IPC_RIMD)