IPC 即 Inter-Process Communication，也就是进程间通信，它指的是在不同进程之间进行数据交换和协调同步的机制。在操作系统里，每个进程都有自己独立的内存空间，一般情况下不能直接访问其他进程的内存，所以需要借助 IPC 机制来实现进程间的信息交互与协作。
进程间通信常用的几种方式
1.管道通信：有名管道，无名管道
2.消息队列
3.共享内存
4.信号量
5.套接字
管道
管道的本质是内核中的一块缓冲区，它在内核空间中开辟了一段连续的内存区域，用于存储进程间传输的数据。在用户程序看来，管道表现为一对文件描述符，一个用于读操作，另一个用于写操作，进程可以像操作普通文件一样对管道进行读写操作，但实际上数据是在内存中的缓冲区里进行传输的。
匿名管道
数据传输 ：当一个进程向管道的写端写入数据时，数据会被复制到内核的管道缓冲区中；另一个进程从管道的读端读取数据时，数据会从管道缓冲区复制到该进程的用户空间。
亲缘关系要求 ：匿名管道只能用于具有亲缘关系的进程之间，如父子进程。这是因为创建管道后，只有创建管道的进程及其子进程才能访问这对文件描述符，其他进程无法获取这些文件描述符，也就无法访问该管道。
创建
匿名管道通过 pipe() 系统调用创建。pipe() 函数会在内核中创建一个管道，并返回两个文件描述符，一个是读端文件描述符（通常用 fd[0] 表示），另一个是写端文件描述符（通常用 fd[1] 表示）
#include <unistd.h>
int pipe(int fd[2])
/*fd‐传出参数：
fd[0]‐读端
fd[1]‐写端
返回值：
0：成功
‐1：创建失败*/管道的读写
读操作
有数据
read(fd[1]) 正常读，返回读出的字节数
无数据
写端被全部关闭，read返回0，相当于读文件到了尾部
没有全部关闭，read阻塞
写操作
读端全部关闭
管道破裂，进程被终止
内核给当前进程发送信号SIGPIPE-13，默认处理动作
读端没全部关闭
缓冲区写满了，write阻塞
缓冲区没满，write继续写，直到写满，阻塞
如何设置非阻塞？
在管道的读写操作中，默认情况下是阻塞模式，即当管道没有数据可读或者管道已满无法写入时，相应的读或写操作会使进程阻塞等待。不过，你可以将管道设置为非阻塞模式，在这种模式下，当无法进行读写操作时，操作会立即返回而不会阻塞进程。
fcntl-变参函数
复制文件描述符-dup
修改文件属性-open的时候对应flag属性
设置方法
//获取原来的flags
int flags = fcntl(fd[0],F_GETFL);
//设置新的flags
flags |=O_NONBLOCK;
//将新的flags设置给文件描述符
fcntl(fd[0],F_SETFL,flags)；查看管道缓冲区的大小
命令
ulimit -a
函数
fpathconf
long size = fpathconf(fd[1],_PC_PIPE_BUF);
printf("size is %ld\n",size);举例：
父子进程使用管道通信
实现 ps aux| grep "bash"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
int ret;
int fd[2];
ret = pipe(fd);
if(ret == -1)
{
printf("create pipe failed!\n");
exit(1);
}
pid_t pid;
pid = fork();
if(pid == -1)
{
printf("fork failed!\n");
exit(1);
}
//ps aux
if(pid>0)
{
close(fd[0]);
dup2(fd[1],STDOUT_FILENO);//数据重定向
execlp("ps","ps","aux",NULL);
perror("execlp");
exit(1);
}
//grep "hash"
else if(pid == 0)
{
close(fd[1]);
dup2(fd[0],STDIN_FILENO);
execlp("grep","grep","bash","--color=auto",NULL);
}
// long size = fpathconf(fd[1],_PC_PIPE_BUF);
// printf("size is %ld\n",size);
printf("pipe[0] is %d\n",fd[0]);
printf("pipe[1] is %d\n",fd[1]);
close(fd[0]);
close(fd[1]);
return 0;
}有名管道
数据传输： 与匿名管道类似，进程通过打开这个 FIFO 文件来获取管道的文件描述符，然后进行读写操作。数据同样是在内核的管道缓冲区中进行传输。
**无亲缘关系限制：**命名管道可以在任意两个进程之间使用，因为它有一个文件系统中的路径名，不同的进程可以通过该路径名打开同一个 FIFO 文件来访问管道。
创建
有名管道通过 mkfifo() 函数创建，它会在文件系统中创建一个特殊类型的文件（FIFO 文件）。这个文件并不实际存储数据，只是作为一个访问管道的接口。
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char \*filename,mode_t mode);
/*功能：创建管道文件
参数：管道文件文件名，权限，创建的文件权限仍然和umask有关系。
返回值：创建成功返回0，创建失败返回-1。*/fifo文件可以使用io函数进程操作：open/close、read/write
不能执行lseek操作
有名管道的读写
读：
int main()
{
int ret,fd,nread;
char readBuff[50] = {0};
ret = mkfifo("/home/cc/ipc/myfifo",0755);
if(ret == -1 )
{
return -1;
}
printf("create fifo success!\n");
fd = open("./myfifo",O_RDONLY);
if(fd < 0)
{
printf("open fifo failed!\n");
return -1;
}
printf("open fifo success!\n");
nread = read(fd,readBuff,50);
printf("read %d byte from fifo %s:\n ",nread,readBuff);
close(fd);
return 0;
}写：
int main()
{
int fd;
char *str = "hello world!";
fd = open("./myfifo",O_WRONLY);
if(fd < 0)
{
printf("open fifo failed!\n");
return -1;
}
printf("open fifo success!\n");
write(fd,str,strlen(str));
close(fd);
return 0;
}消息队列
特点：
消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级
消息队列独立于发送和接收进程，进程终止时，消息队列及其内容仍存在
消息队列可以实现消息的随机查询，消息不一定要先进先出的次序读取，也可以按消息的类型读取。
相关函数
1.创建或打开消息队列
在以下两种情况下，msgget将创建一个新的消息队列：
如果没有与键值key相对应的消息队列，并且flag中包含了IPC_CREAT标志
key参数为IPC_PRIVATE
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);
/*参数：
key:和消息队列关联的key值
msgflg：是一个权限标志，表示消息队列的访问权限，它与文件的访问权限一样。msgflg可以与IPC_CREAT做或
操作，表示当key所命名的消息队列不存在时创建一个消息队列，如果key所命名的消息队列存在时，IPC_CREAT标志会被忽略，而只返回一个标识符。
返回值：成功返回队列ID，失败则返回‐1*/2.发送消息
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
/*参数：
msgid:消息队列的ID
msgp:指向消息缓冲区的指针，消息缓冲区的第一个成员必须是 long 类型，表示消息的类型。
常用结构体msgbuf如下：
struct msgbuf
{
long mtype; //消息类型
char mtext[N]; //消息正文
}
size:发送的消息正文的字节数
flag:
IPC_NOWAIT 消息没有发送完成函数也会立即返回
0：知道发送完成函数才返回
返回值：
成功：0
失败：‐1*/3.接收消息
#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);
/*参数：
msgid:消息队列的ID
msgp:要接收消息的缓冲区
size:要接收的消息的字节数
msgtype:
0:接收消息队列中第一个消息
大于0：接收消息队列中第一个类型为msgtyp的消息
小于0：接收消息队列中类型值不大于msgtyp的绝对值且类型值又最小的消息。
flag:
0:若无消息函数一直阻塞
IPC_NOWAIT：若没有消息，进程会立即返回ENOMSG。
返回值：
成功：接收到的消息i长度
出错：‐1*/4.控制消息队列
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);
/*参数：
msqid：消息队列的队列ID
cmd：
IPC_STAT：把msgid_ds结构中的数据设置为消息队列的当前关联值，即用消息队列的当前关联值覆
盖msgid_ds的值。
IPC_SET：如果进程有足够的权限，就把消息列队的当前关联值设置为msgid_ds结构中给出的值
IPC_RMID：删除消息队列
buf：是指向 msgid_ds 结构的指针，它指向消息队列模式和访问权限的结构
返回值：
成功：0
失败：‐1*/5.ftok函数
系统建立IPC通讯（如消息队列、共享内存时）必须指定一个ID值。通常情况下，该id值通过ftok函数得到。
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok( char * fname, int id )
/*参数：
fname就时你指定的文件名(该文件必须是存在而且可以访问的)。
id是子序号， 虽然为int，但是只有8个比特被使用(0‐255)。
返回值：
当成功执行的时候，一个key_t值将会被返回，否则 ‐1 被返回。*/举例：
通过父子进程让两个进程间互相收发消息
进程1：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
struct msgbuf//magbuf结构体
{
long mtype;
char mtest[128];
char ID[4];
};
int main()
{
struct msgbuf sendbuf,readbuf;//定义读和写的结构体
int msgid;
key_t key;
int readret;
pid_t pid;
key = ftok("a.c",1);//获取key值
msgid = msgget(key,0755 | IPC_CREAT);//创建消息队列
if(msgid == -1 )
{
printf("create message failed!\n");//创建失败就打印
return -1;
}
printf("create message success! msgid is %d\n\n",msgid);//创建成功就打印
system("ipcs -q");//查看队列信息
//init msgbuf
sendbuf.mtype = 100;//发送消息的类型是100
pid = fork();//创建子进程
if(pid>0)//父进程发送类型为100的消息
{
while(1)
{
memset(sendbuf.mtest,0,128);//初始化发送消息的数组
printf("please input to message queue:\n");
fgets(sendbuf.mtest,128,stdin);//向发送消息的数组输入消息
//发送消息到消息队列
msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.mtest),0);
}
}
if(pid == 0)//子进程读取类型为200的消息
{
while(1)
{
memset(readbuf.mtest,0,128);
msgrcv(msgid,(void *)&readbuf,128,200,0);//读取消息到数组
//打印读取到的消息
printf("receive byte from message queue is: %s\n",readbuf.mtest);
}
}
return 0;
}进程2（读取类型为100的消息，发送类型为200的消息）：
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
struct msgbuf
{
long mtype;
char mtest[128];
char ID[4];
};
int main()
{
struct msgbuf sendbuf,readbuf;
int msgid;
key_t key;
int readret;
pid_t pid;
key = ftok("a.c",1);
msgid = msgget(key,0755 | IPC_CREAT);
if(msgid == -1 )
{
printf("create message failed!\n");
return -1;
}
printf("create message success! msgid is %d\n\n",msgid);
system("ipcs -q");
//init msgbuf
sendbuf.mtype = 200;
pid = fork();
if(pid == 0)//child process write 200
{
while(1)
{
memset(sendbuf.mtest,0,128);
printf("please input to message queue:\n");
fgets(sendbuf.mtest,128,stdin);
//send message to message queue
msgsnd(msgid,(void *)&sendbuf,strlen(sendbuf.mtest),0);
}
}
if(pid > 0)//parent process read 100
{
while(1)
{
memset(readbuf.mtest,0,128);
msgrcv(msgid,(void *)&readbuf,128,100,0);
printf("receive byte from message queue is: %s\n",readbuf.mtest);
}
}
return 0;
}共享内存
概念：
共享内存（Shared Memory）就是允许多个进程访问同一个内存空间，是在多个进程之间共享和传递数据最高效的方式。操作系统将不同进程之间共享内存安排为同一段物理内存，进程可以将共享内存连接到它们自己的地址空间中，如果某个进程修改了共享内存中的数据，其它的进程读到的数据也将会改变。
特点：
1.共享内存创建之后，一直存在于内核中，直到被删除或系统关闭
2.共享内存和管道不一样，读取后，内容仍然在共享内存中
相关函数
1.获取或创建共享内存
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
/*参数：
key：IPC_PRIVATE 或 ftok的返回值
size：共享内存区大小
shmflg：同open函数的权限位，也可以用8进制表示法
返回值：
成功：共享内存段标识符‐‐‐ID‐‐‐文件描述符
出错：‐1*/2.把共享内存连接映射到当前进程的地址空间
#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shm_id, const void *shm_addr, int shmflg);
/*参数：
shm_id:ID号
shm_addr:映射到的地址，NULL为系统自动完成的映射
shmflg：
SHM_RDONLY共享内存只读
默认是0，表示共享内存可读写
返回值：
成功：映射后的地址
失败：NULL*/3.将进程里的地址映射删除
#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);
/*参数：
shmid：要操作的共享内存标识符
返回值：
成功：0
出错：‐1*/4.删除共享内存对象
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shm_id, int command, struct shmid_ds *buf);
/*参数：
shmid：要操作的共享内存标识符
cmd ：
IPC_STAT (获取对象属性)‐‐‐ 实现了命令ipcs ‐m
IPC_SET (设置对象属性)
IPC_RMID (删除对象) ‐‐‐实现了命令ipcrm ‐m
buf ：指定IPC_STAT/IPC_SET时用以保存/设置属性
返回值：
成功：0
出错：‐1*/举例：
不同进程用共享内存进行通信
写消息进程：
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
int shmid;
key_t key;
char *p;
key = ftok("a.c",1);
if(key < 0)
{
printf("ftok failed!\n");
return -1;
}
printf("ftok success! key is : %x\n",key);
shmid = shmget(key,128,0777 | IPC_CREAT);
if(shmid < 0)
{
printf("create share memory failed!\n");
return -1;
}
printf("create share memory success shmid = %d\n",shmid);
system("ipcs -m");
p = (char *) shmat(shmid,NULL,0);
if(p == NULL)
{
printf("shmat function failed!\n");
return -2;
}
//write to share memory
fgets(p,128,stdin);
sleep(10);
shmdt(p);
shmctl(shmid,IPC_RMID,0);
return 0;
}收消息进程：
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int shmid;
key_t key;
char *p;
key = ftok("a.c",1);
if(key < 0)
{
printf("ftok failed!\n");
return -1;
}
printf("ftok success! key is : %x\n",key);
shmid = shmget(key,128,0);
if(shmid < 0)
{
printf("create share memory failed!\n");
return -1;
}
printf("create share memory success shmid = %d\n",shmid);
system("ipcs -m");
p = (char *) shmat(shmid,NULL,0);
if(p == NULL)
{
printf("shmat function failed!\n");
return -2;
}
printf("share memory data:%s",p);
shmdt(p);
return 0;
}信号
信号通信，其实就是内核向用户空间进程发送信号，只有内核才能发信号，用户空间进程不能发送信号。
使用命令"kill -l"可以看到内核可以发送的信号
信号通信的框架
信号的发送（发送信号进程）：kill、raise、alarm
信号的接收（接收信号进程） : pause()、 sleep、 while(1)
信号的处理（接收信号进程） :signal
1.信号的发送（发送信号进程）
kill
#include<signal.h>
#include<sys/types.h>
int kill(pid_t pid, int sig);
/*参数：
函数传入值：pid
正数：要接收信号的进程的进程号
0：信号被发送到所有和pid进程在同一个进程组的进程
‐1：信号发给所有的进程表中的进程(除了进程号最大的进程外)
sig：信号
函数返回值：成功 0 出错 ‐1*/2.发信号给自己
raise: 发信号给自己 == kill(getpid(), sig)
#include<signal.h>
#include<sys/types.h>
int raise(int sig);
/*参数：
函数传入值：sig：信号
函数返回值：
成功 0 出错 ‐1*/3.发送闹钟信号
alarm 与 raise 函数的比较：
相同点：让内核发送信号给当前进程
不同点：
alarm 只会发送SIGALARM信号
alarm 会让内核定时一段时间之后发送信号， raise会让内核立刻发信号
#include <unistd.h>
unsigned int alarm(unsigned int seconds)
/*参数：
seconds：指定秒数
返回值：
成功：如果调用此alarm()前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。
出错：‐1*/4.信号的接收
pause 函数的作用是让调用进程暂停执行，直至收到一个能终止该进程或者使进程调用信号处理函数的信号
#include <unistd.h>
int pause(void);
//函数返回值 成功：0，出错：‐15.信号的处理
收到信号的进程，处理的方式：
1.进程的默认处理方式（内核为用户进程设置的默认处理方式）
A：忽略 B：终止进程 C: 暂停
2.自己的处理方式：
自己处理信号的方法告诉内核，这样你的进程收到了这个信号就会采用你自己的的处理方式
#include <signal.h>
void (*signal(int signum, void (*handler)(int)))(int);
/*参数
signum：指定信号
handler
SIG_IGN：忽略该信号。
SIG_DFL：采用系统默认方式处理信号
自定义的信号处理函数指针
函数返回值:
成功：设置之前的信号处理方式
出错：‐1
signal函数有二个参数，第一个参数是一个整形变量（信号值），
第二个参数是一个函数指针，是我们自己写的处理函数；
这个函数的返回值是一个函数指针*/信号量
信号量集合（可以包含多个信号量）IPC对象是一个信号的集合（多个信号量）
1.创建或者获取一个信号量集
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);
/*函数参数：
key：和信号量集关联的key值
nsems: 信号量集中包含的信号量数目
semflg：信号量集的访问权限
函数返回值：
成功：信号量集ID
出错：‐1*/2.控制信号量集
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);
/*函数参数：
semid：信号量集ID
semnum: 要修改的信号量集中信号量编号
cmd :
GETVAL：获取信号量的值
SETVAL：设置信号量的值
IPC_RMID：从系统中删除信号量集合
函数返回值：
成功：0
出错：‐1*/
/*在使用可变参数时，通常需要一个 union semun 类型的参数，该联合体的定义如下：
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)
};*/参数说明：
semid
这是信号量集的标识符，由 semget 函数返回。它用于唯一标识要操作的信号量集。
semnum
表示信号量集中要操作的信号量的编号，编号从 0 开始。如果 cmd 命令不涉及特定的信号量（如 IPC_STAT、IPC_RMID 等），则该参数会被忽略。
cmd
这是一个整数，指定要执行的操作命令，常见的命令如下：
SETVAL：将信号量集中指定编号的信号量的值设置为 arg.val。
GETVAL：获取信号量集中指定编号的信号量的当前值。
SETALL：将信号量集中所有信号量的值设置为 arg.array 数组中的值。
GETALL：将信号量集中所有信号量的当前值存储到 arg.array 数组中。
IPC_STAT：获取信号量集的状态信息，并将其存储在 arg.buf 指向的 struct semid_ds 结构体中。
IPC_SET：将 arg.buf 指向的 struct semid_ds 结构体中的信息设置为信号量集的新状态。
IPC_RMID：删除指定的信号量集，此时 semnum 和 arg 参数会被忽略。
...（可变参数）
这是一个可变参数，根据 cmd 命令的不同，需要传递不同类型的 union semun 参数。如果 cmd 命令不需要额外的参数（如 IPC_RMID），则可以不传递该参数。
返回值：
若操作成功，不同的 cmd 命令会有不同的返回值：
对于 GETVAL 命令，返回指定信号量的当前值。
对于 GETALL 命令，返回 0。
对于 IPC_STAT、IPC_SET、SETVAL、SETALL、IPC_RMID 等命令，返回 0 表示操作成功。
若操作失败，返回 -1，并设置 errno 以指示错误类型。
PV操作
P 操作（申请资源）
功能：P 操作用于申请资源，当一个进程执行 P 操作时，它会尝试获取一个资源。
执行过程：
首先将信号量的值减 1。
检查信号量的值：
如果信号量的值大于等于 0，说明有可用资源，进程可以继续执行。
如果信号量的值小于 0，说明没有可用资源，进程会被阻塞，进入等待队列，直到有其他进程释放资源。
V 操作（释放资源）
功能：V 操作用于释放资源，当一个进程执行 V 操作时，它会释放一个资源。
执行过程：
首先将信号量的值加 1。
检查信号量的值：
如果信号量的值小于等于 0，说明有进程在等待该资源，会唤醒等待队列中的一个进程。
如果信号量的值大于 0，说明没有进程在等待该资源，进程继续执行。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semop(int semid, struct sembuf *sops, size_t nsops);
/*参数：
semid : 信号量的标识码。也就是semget（）的返回值
sops是一个指向结构体数组的指针。
struct sembuf
{
unsigned short sem_num；//信号量编号；
short sem_op; //对该信号量的操作。‐1 ，P操作，1 ，V操作
short sem_flg; //0阻塞，1非阻塞
};
nsops: 操作信号量的个数
返回值：
如果操作成功，semop 函数返回 0。
如果操作失败，返回 -1 */