进程间的通信-IPC

最新推荐文章于 2024-08-28 09:29:32 发布

mx_jun

最新推荐文章于 2024-08-28 09:29:32 发布

阅读量585

点赞数 23

分类专栏： Linux开发文章标签： linux 算法运维

本文链接：https://blog.csdn.net/mx_jun/article/details/137694103

版权

Linux开发专栏收录该内容

8 篇文章 1 订阅

订阅专栏

产生背景:

fork 和 exec实现的通信很低效 -- 残疾通信

IPC包括：

管道:（无名和命名管道）全双工和班双工
消息队列：
信号量;
共享存储：
Scoket，Streams -- 支持不同主机的IPC

管道:

特点:

1.默认无名管道-- 半双工（数据只在一个方向上流动）
2.只能在亲戚进程之间通信，父子，兄弟
3.特殊文件，可以用write ， read 来写入，读取。不是普通文件，并不属于其他任何文件系统，只存在于内存

#半双工：

1.同一时间只能单向通信，一读一写，不能同时写，同时读 -- 算两个
2.管道不存储数据，读完就没了

pipe 函数建立（无名）管道:

头文件:<unistd.h>

函数原型:
int pipe(int fd[2]);

参数-- 2个文件描述符 fd[0]--read fd[1]--write

返回值: 成功返回0，失败返回-1

怎么关闭管道 -- close关闭两个文件描述符 fd[0] fd[1]

=====================================

case -- 实现无名管道的使用:

#include<unistd.h>
#include <sys/types.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include <sys/wait.h>

int main()
{
int fd[2];
char readBuf[128]={0};
if(pipe(fd)==-1){
puts("open pipe fail!!!");
}
int pid=fork();
if(pid<0){
puts("open fork fail!!!");
}
else if(pid>0){
sleep(3); // 先让子进程执行，父进程先睡觉，发现子进程read一直阻塞程序，直到父进程睡完写入数据
puts("this is father to write.");
close(fd[0]); //关闭读，只写 -->半双工
write(fd[1],"Hello from father",strlen("Hello from father"));
wait(NULL);
}
else{
puts("this is son to read.");
close(fd[1]);//关闭写，只读
read(fd[0],readBuf,128);
printf("this is from father:%s\n",readBuf);
exit(0);
}

return 0;
}

=============================

命名管道mkfifo

存在形式: 以文件的形式存放在磁盘中
open 一个 mkfifo时，是否设置非阻塞标志的区别(O_NONBLOCK)

默认没有指定 O_NONBLOCK (是否设置非阻塞标志)
只读open要阻塞到某个其他进程为写而打开此FIFO
只写open要阻塞到某个其他进程为读而打开此FIFO

if 指定 O_NONBLOCK : 一般不用
只读open立即返回，只写open出错返回-1，if没有进程已经为读打开FIFO，则errno设置为ENXIO

case1：实现命名管道:

打开基本读写，防止阻塞

//读程序
#include<unistd.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<errno.h>

int main()
{
if(mkfifo("./file",0600)==-1 && errno!=EEXIST){//判断错误原因是否是已经存在
printf("mkfifo failuer\n");
perror("why");
}
int fd=open("./file",O_RDONLY);
printf("open read success\n");
return 0;
}

// 写程序
#include<unistd.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<errno.h>

int main()
{

int fd=open("./file",O_WRONLY);
printf("open write success\n");
return 0;
}

==================================

case2--加入数据一致读写:

读文件

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

int main()
{
char readBuf[1024]={0};
int nread=0;
if(mkfifo("./file",0600)==-1 && errno!=EEXIST){
printf("mkfifo failuer\n");
perror("why");
}
int fd=open("./file",O_RDONLY); //只读打开
printf("open read success\n");
while(1){ //时刻等待接收
nread=read(fd,readBuf,30);
printf("read num:%d\nmessage:%s\n",nread,readBuf);
}
close(fd);//用完关掉
return 0;
}
写文件:
#include<unistd.h>
#include<stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include<errno.h>
#include<string.h>

int main()
{
int cnt=0;
char * str="The message from fifo.";
int fd=open("./file",O_WRONLY); // 只写打开
printf("open write success\n");
while(1){
sleep(1); //每秒写入一次
int nwrite=write(fd,str,strlen(str));

}
close(fd);
return 0;
}

======================================

消息队列:

linux内核中管理消息队列的链表
原理:
算是一个中间桥梁 -- B把数据写到内核中的消息队列，A读取队列中B的数据，当A,B使用同一个队列通讯的时候，实现A,B的通信

特点：

1.消息队列是面向记录的，其中的消息、具有特定的格式和特定的优先级
2.消息队列独立与发送和接收进程，进程终止，消息队列也不会清除
3.消息队列可以实现信息的随机查询，按消息类型读取(链表的数据结构特性)

实现A,B通信:
A:1.获取队列 2读
B：1.获取队列 3.写

消息队列API

头文件

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
-- 创建/打开消息队列，成功返回队列ID，失败返回-1:

函数原型
int msgget(key_t key, int msgflg);
//创建新的消息队列:
1.if 没有键值与key相同的消息队列，并且flag 包含 IPC_CREAT标志位
2.key的参数为 IPC_PRIVATE

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
-- 添加消息，成功返回0，失败-1
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
-- 读取消息，成功返回队列数据长度，失败返回-
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
msgtyp ==0，返回消息队列中的第一个消息
msgtyp >0 , 返回消息队列中类型为msgtyp 的第一个消息
msgtyp <0,返回队列中消息类型绝对值小于等于msgtyp 绝对值的消息，if存在多个，则去类型在，制最小的消息

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
-- 消息队列的的控制(删除):成功返回0，失败返回-1
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

//可以看到四个API的头文件都一样

======================================

case1：实现消息共享:

//获取队列写入队列
#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);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
struct msgbuf
{
long mtype;
char mtext[128];
};

int main()
{
struct msgbuf sendBuf={888,"this is message from que."};
int msgId=msgget(0x1234,IPC_CREAT|0777);//创建消息队列
if(msgId == -1){
puts("get message que failed\n");
}
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);// 向队列中添加消息

return 0;
}

// 获取队列，读取队列消息

#include<stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.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);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
struct msgbuf
{
long mtype;
char mtext[128];
};

int main()
{
struct msgbuf readBuf;
int msgId=msgget(0x1234,IPC_CREAT|0777);// 获取消息队列
if(msgId == -1){
puts("get message que failed\n");
}
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0); //读取队列中的消息
printf("read from message que :%s\n",readBuf.mtext);

return 0;
}

=================================

case2:消息队列实现双全工同时收发

#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);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
struct msgbuf
{
long mtype;
char mtext[128];
};

int main()
{
struct msgbuf readBuf;
int msgId=msgget(0x1234,IPC_CREAT|0777);
if(msgId == -1){
puts("get message que failed\n");
}
//先接收
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),888,0);
printf("read 1 from message que :%s\n",readBuf.mtext);
//再发送
struct msgbuf sendBuf={988,"this is return message from que."};//换一个接口988
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
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);
// int msgctl(int msqid, int cmd, struct msqid_ds *buf);
struct msgbuf
{
long mtype;
char mtext[128];
};

int main()
{
struct msgbuf sendBuf={888,"this is send message from que."};
struct msgbuf readBuf;
int msgId=msgget(0x1234,IPC_CREAT|0777);
if(msgId == -1){
puts("get message que failed\n");
}
//先发送
msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);

//再接收
msgrcv(msgId,&readBuf,sizeof(readBuf.mtext),988,0);//换一个接口988
printf("read 2 from message que :%s\n",readBuf.mtext);
return 0;
}
==================================

共享内存:

描述:

A,B之间创建一块共享内存，让他们的信息交流无障碍(使用频率高 -- 先进好用)

Linux 信号(Signal):

对于linux来说，信号是软中断，许多主要重新都需要中断。ctrl + c退出也是中断程序。
但A,B同时写共享内存的一块地方的时候就会出现信息杂糅 -- 信号来处理

信号定义在"signal.h"头文件里

指令kill -l: 查看系统中的所有信号;

信号处理方式:

忽略 (SIGNKILL SIGNSTOP不能忽略)
捕捉: 类似槽函数，告诉内核希望如何处理某信号 -- 信号的最大意义 -- 实现异步通信
默认: 系统对每个信号都有其默认处理动作

kill -9 pid -- 杀死进程 9--对应信号SIGNKILL

=====================================

signal:

信号处理函数；
signal
高级:
sigaction

#include <signal.h>

typedef void (*sighandler_t)(int);

sighandler_t signal(int signum, sighandler_t handler);

函数原型:
signal(SIGINT,handler); -- 收到SINGINT 信号的时候调用handler函数

case1：不给ctrl + c退出的程序(ctrl +z -- signstop) -- 检测你发送的信号

#include<stdio.h>
#include<signal.h>
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;

default:
break;
}

printf("never be killer\n");
}

int main()
{
signal(SIGINT,handler);
signal(SIGKILL,handler);
signal(SIGUSR1,handler);
while(1);

return 0;
}

kill函数

头文件:
#include <sys/types.h>
#include <signal.h>

函数原型:

int kill(pid_t pid, int sig); // 使用kill发信号
//ASCLL码值转整形数
#include <stdlib.h>

int atoi(const char *nptr);
long atol(const char *nptr);
long long atoll(const char *nptr);

==================

case: kill函数发信号

#include<stdio.h>
#include<signal.h>
#include<sys/types.h>
#include<stdlib.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\t pid=%d\n",signum,pid);
// int kill(pid_t pid, int sig);
// kill(pid,signum);

sprintf(cmd,"kill -%d %d",signum,pid);
system(cmd);
puts("send signal ok");
return 0;
}
=============================

sigaction

头文件

#include <signal.h>

函数原型

int sigaction(int signum, const struct sigaction *act,
struct sigaction *oldact);

发信号:sigqueue

头文件

#include <signal.h>

函数原型

int sigqueue(pid_t pid, int sig, const union sigval value);

case：sigaction实现数据接收

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

// int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

void handler(int signum, siginfo_t *info, void *context)
{
printf("signum=%d\n", signum);
if (context != NULL)
{
printf("get data = %d\n", info->si_int);
printf("get data = %d\n", info->si_value.sival_int);
printf("from:%d\n",info->si_pid);
}
}

int main()
{
struct sigaction act;
printf("pid = %d\n",getpid());
act.sa_sigaction = handler;
act.sa_flags = SA_SIGINFO;
sigaction(SIGUSR1, &act, NULL);
while (1);
return 0;
}

---------------
发数据

#include<signal.h>
#include<stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include<stdlib.h>
// int sigqueue(pid_t pid, int sig, const union sigval value);

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

signum=atoi(argv[1]);
pid=atoi(argv[2]);
//printf("num=%d\t pid=%d\n",signum,pid);
union sigval value;
value.sival_int=100;//待发送的数据
sigqueue(pid,signum,value);//发数据
printf("pid = %d\n",getpid());

puts("done");
return 0;
}
=====================================

信号量的三个API:

头文件

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
// 创建/获取一个信号量组:if成功放回信号量集ID，失败放回-1
int semget(key_t key, int nsems, int semflg);
//对信号量组进行操作，改变信号量额值，成功0，失败-1
int semop(int semid, struct sembuf *sops, size_t nsops);

//int semtimedop(int semid, struct sembuf *sops, size_t nsops,
const struct timespec *timeout);
// 控制信号量相关信息
int semctl(int semid, int semnum, int cmd, ...);

case1:初始化信号量:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

union semun
{
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO
(Linux-specific) */
};

int main(int argc, char **argv)
{
int semid;
key_t key;
key = ftok(".", 2);
// int semget(key_t key, int nsems, int semflg);
// 获取创建信号量
semid = semget(key, 1, IPC_CREAT | 0666); // 1 --希望只有一个信号量
union semun initsem;
initsem.val = 1;
// 初始化信号量
semctl(semid, 0, SETVAL, initsem); // 0--操作第0个信号量
// SETVAL -- 设置信号量的值
int pid = fork();
if(pid>0){
puts("this is father");
//去拿🔓

//🔓放回去
}
else if(!pid){
puts("this is son");
}
else{
puts("fork error!!!");
}
return 0;
}

============================

case2：控制信号量控制子进程先进行:

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

union semun
{
int val; /* Value for SETVAL */
struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* Array for GETALL, SETALL */
struct seminfo *__buf; /* Buffer for IPC_INFO
(Linux-specific) */
};
void pGetKey(int id)
{
//int semop(int semid, struct sembuf *sops, size_t nsops);
struct sembuf set;
set.sem_num=0;
set.sem_op=-1;
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("get key\n");

}

void vPutBackKey(int id)
{
//int semop(int semid, struct sembuf *sops, size_t nsops);
struct sembuf set;
set.sem_num=0;
set.sem_op=1;
set.sem_flg=SEM_UNDO;
semop(id,&set,1);
printf("put back key\n");

}

int main(int argc, char **argv)
{
int semid;
key_t key;
key = ftok(".", 2);
// int semget(key_t key, int nsems, int semflg);
// 获取创建信号量
semid = semget(key, 1, IPC_CREAT | 0666); // 1 --希望只有一个信号量
union semun initsem;
initsem.val = 0; // 房间钥匙被拿
// 初始化信号量
semctl(semid, 0, SETVAL, initsem); // 0--操作第0个信号量
// SETVAL -- 设置信号量的值
int pid = fork();
if(pid>0){
//去拿🔓
pGetKey(semid);
puts("this is father");

//🔓放回去
vPutBackKey(semid);
}
else if(!pid){
puts("this is son");
//🔓放回去
vPutBackKey(semid);
}
else{
puts("fork error!!!");
}
return 0;
}