✅<1>主页：：我的代码爱吃辣
📃<2>知识讲解：Linux——进程间通信——管道通信
☂️<3>开发环境：Centos7
💬<4>前言：进程间通信（InterProcess Communication，IPC）是指在不同进程之间传播或交换信息。
目录
一.什么是进程间通信
二.进程间通信目的
三.进程间通信发展
四.什么是管道
五.匿名管道
六.父子进程管道通信
1.匿名管道的场景与特点
2. 用fork来共享管道原理
七.基于匿名管道实现进程池
一.什么是进程间通信
进程间通信（InterProcess Communication，IPC）是指在不同进程之间传播或交换信息。
二.进程间通信目的
- 数据传输：一个进程需要将它的数据发送给另一个进程
- 资源共享：多个进程之间共享同样的资源。
- 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
- 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
三.进程间通信发展
管道
- 匿名管道pipe
- 命名管道
System V IPC
- System V 消息队列
- System V 共享内存
- System V 信号量
POSIX IPC
- 消息队列
- 共享内存
- 信号量
- 互斥量
- 条件变量
- 读写锁
四.什么是管道
- 管道是Unix中最古老的进程间通信的形式。
- 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。
五.匿名管道
头文件：#include <unistd.h>
功能：创建一无名管道。
原型：int pipe(int fd[2]);
参数：fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端。
返回值：成功返回0，失败返回错误代码。
测试代码：
pipe.cc:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main(void)
{int fds[2]; // f[0]管道读端，f[1]管道写端char buf[100];int len;// 创建管道if (pipe(fds) == -1)perror("make pipe"), exit(1);// read from stdinwhile (fgets(buf, 100, stdin)){len = strlen(buf);// 写入管道if (write(fds[1], buf, len) != len){perror("write to pipe");break;}memset(buf, 0, sizeof(buf));// 从管道中读取if ((len = read(fds[0], buf, 100)) == -1){perror("read from pipe");break;}// 写入显示器if (write(1, buf, len) != len){perror("write to stdout");break;}}
}makefile：
pipe:pipe.ccg++ -o $@ $^ -std=c++11.PHONY:clean
clean:rm -rf pipe测试结果：
六.父子进程管道通信
我们知道fork之后，子进程会继承父进程的代码，数据会发生写时拷贝，那么父进程的文件描述符会不会被继承呢？会的。那么父进程创建的管道，其中的两个文件描述符一个指向管道的读端，一个指向管道的写端，也会被子进程继承。
1.匿名管道的场景与特点
管道的特点：
- 管道只具有单向通信的功能。
- 管道的本质是文件，因为fd的生命周期是随进程的，所以管道的生命周期也是随进程的。
- 管道通信，通常用来进行具有“血缘”关系的进程，进行进程间的通信。常用父子进程通信，
- 在管道的通信中，写入的次数，和读取的次数，不是严格匹配的，读写次数没有强相关，是面向字节流。
- 具有一定的协同能力，如果写端没有写入，读端会被阻塞——自带同步机制。
特殊场景：
- 如果我们read读取完毕了所有的管道数据，如果对方不发，我就只能等待。
- 如果我们writer端将管道写满了，我们还能写吗?不能
- 如果我关闭了写端，读取完毕管道数据，在读，就会read返回0，表明读到了文件结尾
- 写端一直写，读端关闭，会发生什么呢?没有意义。OS不会维护无意义，低效率，或者浪费资源的事情。OS会杀死一直在写入的进程!OS会通过信号来终止进程，（13）SIGPIPE。
测试代码：
#include <iostream>
#include <string>
#include <cerrno>
#include <cassert>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>int main()
{// 让不同的进程看到同一份资源！！！！// 任何一种任何一种进程间通信中，一定要 先 保证不同的进程之间看到同一份资源int pipefd[2] = {0}; // pipefd[0] 读端， pipe[1]写端// 1. 创建管道int n = pipe(pipefd);if (n < 0){std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;return 1;}std::cout << "pipefd[0]: " << pipefd[0] << std::endl; // 读端std::cout << "pipefd[1]: " << pipefd[1] << std::endl; // 写端// 2. 创建子进程pid_t id = fork();assert(id != -1);if (id == 0) // 子进程{// 3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入close(pipefd[0]);// 4. 开始通信 -- 结合某种场景const std::string namestr = "hello,我是子进程";int cnt = 1;char buffer[1024];while (true){snprintf(buffer, sizeof buffer, "%s, 计数器: %d, 我的PID: %d", namestr.c_str(), cnt++, getpid());write(pipefd[1], buffer, strlen(buffer));sleep(1);}// 退出时关闭打开的文件描述符close(pipefd[1]);exit(0);}// 父进程// 3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入close(pipefd[1]);// 4. 开始通信 -- 结合某种场景char buffer[1024];int cnt = 0;while (true){// sleep(10);// sleep(1);int n = read(pipefd[0], buffer, sizeof(buffer) - 1);if (n > 0){buffer[n] = '\0';std::cout << "我是父进程, child give me message: " << buffer << std::endl;}else if (n == 0){std::cout << "我是父进程, 读到了文件结尾" << std::endl;break;}else{std::cout << "我是父进程, 读异常了" << std::endl;break;}sleep(1);if (cnt++ > 5)break;}// 父进程读端关闭，子进程会收到13号信号close(pipefd[0]);// 回收子进程的僵尸状态int status = 0;waitpid(id, &status, 0);std::cout << "子进程pid:" << id << ",收到的信号sig: " << (status & 0x7F) << std::endl;sleep(1);return 0;
}测试结果：
2. 用fork来共享管道原理
所以，看待管道，就如同看待文件一样！管道的使用和文件一致，迎合了“Linux一切皆文件思想”。
七.基于匿名管道实现进程池
当没有数据可读时，read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
如果我们使用，父进程来控制写端，子进程进行读取，发送数据让子进程执行特定的任务，我们就可以实现对子进程的控制。
代码：
CtrlProc.cc：
#include <iostream>
#include <vector>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include "Task.hpp"using namespace std;
#define NUM_PROC 5struct child_pip
{child_pip(int fd, pid_t pid): _fd(fd), _pid(pid){}~child_pip(){}int _fd;pid_t _pid;
};void WaitCommand()
{Task task;int command;while (1){size_t n = read(0, &command, sizeof(int));if (n == 4) // 读取成功{task.funcs[command]();}else if (n == 0) // 读取失败{break;}else{break;}}
}
void creatproc(vector<child_pip> &child_pip_v)
{for (int i = 0; i < NUM_PROC; i++){// 1.创建管道int pipfd[2];pipe(pipfd);// 2.创建子进程pid_t pid = fork();if (pid < 0)perror("fork");// 我们想让子进程从管道读，父进程向管道写if (pid == 0) // 子进程{// 3.关闭不必要的文件描述符close(pipfd[1]);// 3.1重定向，将来子进程指向0号文件描述符读取dup2(pipfd[0], 0);WaitCommand();exit(0);}// 父进程// 3.关闭不必要的文件描述符cout << "子进程pid:" << pid << endl;close(pipfd[0]);// 建立好子进程与管道的映射,父进程的写端口，和子进程pidchild_pip_v.push_back(child_pip(pipfd[1], pid));}
}void ctrlproc(vector<child_pip> &child_pip_v)
{while (1){int command = 0;cin >> command;if (command == -1)break;int i = rand() % NUM_PROC;write(child_pip_v[i]._fd, &command, sizeof(int));}
}void waitproc(vector<child_pip> &child_pip_v)
{int status = 0;for (int i = 0; i < child_pip_v.size(); i++){close(child_pip_v[i]._fd);}// sleep(5);for (int i = 0; i < child_pip_v.size(); i++){waitpid(child_pip_v[i]._pid, &status, 0);cout << "子进程:" << child_pip_v[i]._pid << "退出" << endl;}
}int main()
{vector<child_pip> child_pip_v;creatproc(child_pip_v);ctrlproc(child_pip_v);waitproc(child_pip_v);return 0;
}
Task.cc:
#include <vector>
#include <iostream>
#include <unistd.h>using namespace std;
typedef void (*fun_t)();void beatxyy()
{cout << "子进程：" << getpid() << ",执行数据库" << endl;
}void beatxyf()
{cout << "子进程：" << getpid() << ",写入日志" << endl;
}void beatwy()
{cout << "子进程：" << getpid() << ",读取网卡" << endl;
}void beatwj()
{cout << "子进程：" << getpid() << ",刷新缓冲区" << endl;
}void beatxjy()
{cout << "子进程：" << getpid() << ",数据比对" << endl;
}struct Task
{Task(){funcs.push_back(beatxyy);funcs.push_back(beatxyf);funcs.push_back(beatwy);funcs.push_back(beatwj);funcs.push_back(beatxjy);}vector<fun_t> funcs;
};makefile:
CtrlProc:CtrlProc.ccg++ -o $@ $^ -std=c++11.PHONY:clean
clean:rm -rf CtrlProc测试结果：
注意：
为什么这里的waitproc我们要分开成两个循环，如果一个循环，文件描述符会无法关闭完，子进程也就无法退出。
我们关闭了第一个文件描述符，第一个管道由于继承问题，第一个管道还会有后面的子进程也会指向。最终导致我们只能有最后一个子进程先退出了，其他子进程进程陆续退出，此时进程等待也已经结束了，除了最后一个子进程。其他子进程的僵尸状态都没有被回收。
