目录
1. 进程间通信
1.1. 进程间通信的目的
1.2. 如何实现进程间通信
2. 管道通信
2.1. 匿名管道
2.1.1 创建匿名管道
2.1.2 . 深入理解匿名管道
2.2. 命名管道
2.2.1. 创建命名管道
3. system V 标准进程间通信
3.1. 共享内存
3.1.1. 实现原理
3.1.2. 代码实现
3.2. 消息队列(了解)
3.2.1 实现原理
3.3. 信号量(了解)
3.3.1. 实现原理
1. 进程间通信
1.1. 进程间通信的目的
进程之间可能会存在特定的协同工作的场景，而协同就必须要进行进程间通信，协同工作可能有以下场景。
数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它发生了某种事件。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另 一个进程的所有陷入和异常，并能够及时知道它的状态改变
1.2. 如何实现进程间通信
由于一个进程是不能访问到另一个进程的资源的，即进程之前是具有独立性的。
那么进程之间要通信，就不能使用属于进程的资源，而应该使用一份公共的资源。
所以进程间通信的本质是：由OS参与，提供一份所以进程都能访问的公共资源。
而公共资源是什么，例如：文件、队列、内存块。
2. 管道通信
2.1. 匿名管道
适用场景：父子进程间通信。
基本原理：通过打开同一个文件，父子进程对文件进行读写操作，父子进程在文件内核缓冲区中写入或读出数据，从而实现通信。
2.1.1 创建匿名管道
使用接口
pipe：创建一个管道，参数为输出型参数，打开两个文件描述符(fd)，返回值为0表示打开失败。
具体代码：
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>int main()
{int pipefd[2] = {0};if(pipe(pipefd) != 0){perror("pipe");return 1;}// 父进程读取数据，子进程写入数据// 规定：pipedfd[0]为读取端，pipefd[1]为写入端if(fork() == 0){//childclose(pipefd[0]);// 关闭读取端const char* msg = "hello world\n";while(1){write(pipefd[1], msg, strlen(msg));sleep(1);}exit(0);}// fatherclose(pipefd[1]);// 关闭写入端while(1){char buffer[64] = {0};ssize_t s = read(pipefd[0], buffer, sizeof(buffer));// 如果read的返回值是0，表示子进程关闭了文件描述符if(s == 0){printf("child quit\n");break;}else if(s > 0){buffer[s] = 0;// 子进程写入时没有添加'\0'，需要手动添加printf("child say：%s",buffer);}else{printf("read error\n");break;}}return 0;
}子进程写入数据，父进程读出数据，这样就实现了简单的父子进程间的通信：
问题分析：为什么上面的代码中，需保证读端比写端快？
因为管道是面向字节流的，字符串之间没由规矩分隔符，如果读取速度慢于写入速度，可能读端还没有将整个字符串读完，写端又写入了数据，会导致数据混乱。
2.1.2 . 深入理解匿名管道
匿名管道的五个特点：
只能单向通信的信道
面向字节流
只能在父子进程间通信
管道自带同步机制，原子性写入
管道也是文件，管道的生命周期随进程
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>int main()
{int pipefd[2] = {0};if(pipe(pipefd) != 0){perror("pipe");return 1;}if(fork() == 0){//childclose(pipefd[0]);// 关闭读取端int count = 0;char c = 'a';while(1){write(pipefd[1], &c, 1);count++;printf("%d\n", count);}exit(0);}// fatherclose(pipefd[1]);// 关闭写入端while(1){sleep(5);char buffer[4*1024+1] = {0};ssize_t s = read(pipefd[0], buffer, sizeof(buffer)-1);buffer[s] = 0;printf("father take：%s\n", buffer);}return 0;
}
云服务器中，管道的大小为64KB，写端写满后不会再写，会等读端读取管道内容，且读取4KB后才会重新写入（读端的容量为4KB）。
管道读写规则
当没有数据可读时
O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。 O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
当管道满的时候
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
如果所有管道写端对应的文件描述符被关闭，则read返回0 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
即匿名管道的四种情况：
读端不读或读的慢，写端要等读端
读端关闭，写端收到SIGPIPE信号直接终止
写端不写或者写的慢，读端要等写端
写端关闭，读端会读完管道内的数据然后再读，会读到0，表示读道文件结尾
2.2. 命名管道
为了解决匿名管道只能在父子进程间通信的缺陷，引入了命名管道。
其性质除了能让任意进程间通信外，与匿名管道基本一致，即创建一个文件一个进程往文件中写数据，一个进程读数据，且不让文件内容刷新到磁盘上，从而实现任意进程间的通信。
2.2.1. 创建命名管道
命令行创建
使用命令 mkfifo 管道
然后使用一个简单的shell脚本，将 hello world 每间隔一秒输入到管道中，然后另一边读取管道中的内容。
通过这种方式，显示不是重点。
代码创建
使用接口：mkfifo
因为是不同进程间的通信，所以这里需要创建两个进程：
comm.h
#include<string.h> #include<stdio.h> #include<sys/stat.h> #include<sys/types.h> #include<fcntl.h> #include<unistd.h> #define MY_FIFO "./fifo"server.c#include"comm.h" int main() {umask(0);if(mkfifo(MY_FIFO, 0666) < 0) //创建命名管道{perror("mkfifo");return 1;} // 只需要文件操作即可int fd = open(MY_FIFO, O_RDONLY);if(fd < 0){perror("open");return 2;} // 业务逻辑while(1){char buffer[64] = {0};ssize_t s = read(fd, buffer, sizeof(buffer)-1);if(s > 0){buffer[s] = 0;printf("client-> %s\n", buffer);}else if(s == 0){printf("client quit...\n");break;}else{perror("read");break;}} close(fd);return 0; }client.c
#include"comm.h" int main() {int fd = open(MY_FIFO, O_WRONLY);if(fd < 0){perror("open");return 1;} // 业务逻辑while(1){printf("请输入-> ");fflush(stdout);char buffer[64] = {0};ssize_t s = read(0, buffer, sizeof(buffer)-1); // 从显示器上读取数据，然后写入到文件中if(s > 0){buffer[s-1] = 0;printf("%s\n", buffer);write(fd, buffer, strlen(buffer));}}return 0; }
运行起来后，就实现了简单的命名管道的通信：
为什么命名管道有名字，而匿名管道没有？
命名管道有名字是为了保证让不同进程看到同一个文件。
匿名管道没有名字，是因为他是通过父子继承放入方式，看到同一份资源不需要名字。
3. system V 标准进程间通信
system V：同一主机内的进程间通信方案，在OS层面专门为进程间通信设计的方案
进程间通信的本质：让不同的进程看到同一份资源
system V标准下的三种通信方式
共享内存
消息队列
信号量
3.1. 共享内存
3.1.1. 实现原理
通过系统调用，在内存中创建一份内存空间
通过系统调用，让进程"挂接"到这份新开辟的内存空间上(即在页表上建立虚拟地址与物理地址的映射关系)
去关联(挂接)
释放共享内存
使用接口：
shmget：申请共享内存
#include <sys/ipc.h> #include <sys/shm.h> int shmget(key_t key, size_t size, int shmflg); // key：创建共享内存时的算法和数据结构中唯一标识符，由用户自己设定需用到接口ftok // size：共享内存的大小，建议是4KB的整数倍 // shmflg：有两个选项：IPC_CREAT(0)，创建一个共享内存，如果已经存在则返回共享内存；IPC_EXCL(单独使用没有意义) // IPC_CREAT|IPC_EXCL(如果调用成功，一定会得到一个全新的共享内存)：如果不存在共享内存，就创建；反之，返回出错 // 返回值：shmdi，描述共享内存的标识符 #include <sys/types.h> #include <sys/ipc.h> key_t ftok(const char *pathname, int proj_id); // 算法生成key // pathname：自定义路径名 // proj_id：自定义项目idshmctl：控制共享内存
#include <sys/ipc.h> #include <sys/shm.h> int shmctl(int shmid, int cmd, struct shmid_ds *buf); // shmid：共享内存id // cmd：控制方式，这里我们只使用IPC_RMID 选项，表示删除共享内存 // buf：描述共享内存的数据结构struct_shmid_ds结构体：
shmat、shmdt：关联、去关联共享内存
#include <sys/types.h> #include <sys/shm.h> void *shmat(int shmid, const void *shmaddr, int shmflg); // 关联 // shmid：共享内存id // shmaddr：挂接地址(自己不知道地址，所以默认为NULL) // shmflg：挂接方式，默认为0 // 返回值：挂接成功返回共享内存起始地址(虚拟地址)，类似C语言malloc int shmdt(const void *shmaddr); // 去关联(取消当前进程和共享内存的关系) // shmaddr：去关联内存地址，即shmat返回值 // 返回值：调用成功返回0，失败返回-1
命令行查看共享内存：
ipcs -m // ipcs 查看ipc资源
system V 的IPC资源，生命周期随内核，只能通过程序员显示释放(或者OS重启)
命令行删除共享内存方法：
ipcrm -m shmid
3.1.2. 代码实现
comm.h
#include<stdio.h> #include<sys/ipc.h> #include<sys/types.h> #include<sys/shm.h> #include<unistd.h> #include<string.h> #define PATH_NAME "./" #define PROJ_ID 0x6666 #define SIZE 4096server.c
#include"comm.h" int main() {key_t key = ftok(PATH_NAME, PROJ_ID);if(key < 0){perror("ftok");return 1;}printf("key-> %x\n", key); int shmid = shmget(key, SIZE, IPC_CREAT|IPC_EXCL|0666); // 创建全新共享内存if(shmid < 0){perror("shmget");return 1;}printf("shmid-> %d\n", shmid); char* mem = (char*)shmat(shmid, NULL, 0);// 通信逻辑while(1){printf("%s\n", mem);// 打印mem内存中的内容sleep(1); } shmdt(mem); shmctl(shmid, IPC_RMID, NULL); return 0; }client.c
#include"comm.h" int main() {key_t key = ftok(PATH_NAME, PROJ_ID);if(key < 0){perror("ftok");return 1;} int shmid = shmget(key, SIZE, IPC_CREAT);if(shmid < 0){perror("shmget");return 1;} // 挂接char* mem = (char*)shmat(shmid, NULL, 0);// 通信逻辑char c = 'A';while(c <= 'Z'){mem[c - 'A'] = c;c++;mem[c - 'A'] = 0;sleep(2);} // 去关联shmdt(mem); //该共享内存不由client创建，所以不用它删除 return 0; }
运行结果：
使用共享内存进行通信时，不需要使用read和write 接口。
共享内存是所有进程间通信中速度最快的。
共享内存不提供任何同步或互斥机制，需要程序员自行保证数据安全。
ps: 共享内存在内核中的申请的基本单位是页，内存页的大小为4KB，如果申请4097个字节，内核会分配8KB空间。
3.2. 消息队列(了解)
3.2.1 实现原理
接口类似与共享内存，底层是一个队列结构
msgget：创建消息队列
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgget(key_t key, int msgflg);msgctl：控制消息队列
#include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgctl(int msqid, int cmd, struct msqid_ds *buf);
3.3. 信号量(了解)
什么是信号量？
信号量不是以传输数据为目的，通过共享“资源”的方式，来达到多个进程的同步和互斥的目的！
本质是一个计数器，衡量临界资源中的资源数目。
临界资源：同时被多个进程访问的资源。例如：显示器打印，共享内存，消息队列
临界区：用来访问临界资源的代码，就是临界区。
原子性：执行事件时没有中间过程，且操作不可中断，要么执行完，要么没有执行。
互斥：在任意时刻，只允许一个进程进入临界资源。
同步：两个或多个数据库、文件、模块、线程之间用来保持数据内容一致性的机制。
3.3.1. 实现原理
接口类似共享内存
semget：创建信号量
#include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semget(key_t key, int nsems, int semflg);semctl：控制信号量
#include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semctl(int semid, int semnum, int cmd, ...);
所有的ipc资源都是通过数组组织起来的。
