目录
一.什么是匿名管道
匿名管道是linux中一种非常古老的进程间通信方式，本质上就是一个内存级的文件。
一般用于父子进程间通信。概念上就是父进程与子进程共同使用一个管道文件来传输数据。
虽然父子进程都有对管道的读和写功能，但在使用时只能读或者写，因此管道是单向通信，半双工模式。
父进程把数据写入管道，子进程从管道中读取：
二.如何使用匿名管道
（一）.pipe原理
linux为我们提供了系统接口pipe，用于创建管道进行通信。
参数是长度为2的整形数组，pipefd[0]代表读端文件描述符，pipefd[1]代表写端文件描述符。
返回值是int，创建成功返回0，失败返回-1，同时记录进errno。
pipe的使用原理上，就是首先父进程创建一个管道文件，但同时赋予管道文件两个文件描述符。
一个是以读方式打开即pipefd[0]，另一个是以写方式打开即pipefd[1]。
之后创建子进程，由于子进程会对父进程进行拷贝，会把父进程的fd_array同时拷贝一份，也就拥有了管道对应的两个文件描述符（读端&写端）。
图示如下：
（二）.pipe使用
以下面代码为例：
父进程使用write接口将字符串给管道，子进程从管道中接收字符串并打印。
同时，子进程的read系统接口会阻塞，直到父进程往管道中写完数据，read一次性将此时管道内数据读取完并清空管道。
当父进程关闭管道后，若管道中还有数据时read函数会一次性读取完并在下一次读取时返回0，没有数据时直接返回0。
#include<iostream>
#include<cstdio>
#include<unistd.h>
#include<string>
#include<assert.h>
using namespace std;
int main()
{
int pfd[2] = { 0 };
int ret = pipe(pfd);
assert(ret == 0);
pid_t id = fork();
assert(id >= 0);
if(id == 0)
{
close(pfd[1]);//关闭写端
char GetStr[1024] = { 0 };
ssize_t i = read(pfd[0], GetStr, sizeof GetStr);//接收数据
GetStr[i] = '\0';
cout << GetStr << endl;
exit(0);
}
//父进程
close(pfd[0]);
char str[1024] = "hello world";
write(pfd[1], str, sizeof str);//发送数据
return 0;
}
三.命名管道概念及区别
（一）.什么是命名管道
顾名思义，这是有名字的管道。它以文件的形式存在于系统中，在磁盘中有对应的节点但没有为其分配数据块（block）。
换一种说法，它是能被我们看到（看到名字）且有inode编号的文件，但是inode中记录的block数量为0，使用时只能使用内存空间。
（二）.与匿名管道的联系和区别
①和匿名管道一样，本质上都是利用内存空间进行通信。
②都是半双工通信，任意时刻只能向一端发送数据
③管道生命周期不同，匿名管道伴随进程，命名管道只要不删除一直存在。
④通信对象不同，匿名管道一般用于父子进程通信，命名管道可用于任意进程间通信。
⑤创建管道的方式不同，匿名管道使用pipe，命名管道使用mkfifo
四.命名管道的使用
（一）.系统指令
系统指令方式：$mkfifo 路径+管道名
演示：
（二）.mkfifo
代码方式：int mkfifo(const char *pathname, mode_t mode)
自制翻译：int mkfifo(文件路径+管道名，文件权限);
头文件：<sys/types.h>、<sys/stat.h>
返回值int：成功返回0，失败返回-1并在errno中记录。
文件权限：用于规定管道文件读写权限， 实际权限=设定权限&~umask。
比如0666实际上就是：0666 & ~0002（umask == 0002）即0661。
因为命名管道是一个文件，使用方式与文件的使用方式相同，但如果只打开了读端或写端，该端口就会阻塞，直到写端或读端打开为止。
使用方式：
//读端
int i = mkfifo("./fifo.ipc", 0666);//创建命名管道
assert(i >= 0);
int fd = open("./fifo.ipc", O_RDONLY);//打开管道读端，O_RDONLY：只读方式打开
. . .
char buf[1024] = { '\0' };
ssize_t s = read(fd, buf, sizeof buf);//读取数据
. . .
close(fd);//关闭读端管道
//写端
int fd = open("./fifo.ipc", O_WRONLY);打开管道写端，O_WRONLY：只写方式打开
. . .
std::string buf;
std::getline(std::cin, buf);
ssize_t s = write(fd, buf.c_str(), buf.size());//向管道写入数据
. . .
close(fd);//关闭写端管道
五.进程池
（一）.概念与原理
进程池可以简单理解为父进程调度多个子进程完成不同的任务。类似于人脑与四肢的关系。
我们可以自制一个简易的进程池。
首先利用父进程fork多个子进程，每次fork之前都先使用pipe创建与这个子进程用于联系的管道。
同时记录子进程的pid和其对应的读端文件描述符（用于向其中传输数据与回收子进程）。
之后调度某个子进程传输相关数据。
（二）.代码原理与分析
在这份代码中，模拟实现5个函数，父进程会随机选择任意一个子进程调用任意一个函数。
子进程调用系统read函数接收数据并调用对应的模拟函数。
为了提高英语能力，小编选择使用英文注释????。
//"Command.h"
#pragma once
#include<iostream>
#include<cstdio>
#include<vector>
#include<functional>
using namespace std;
typedef function<void()> func;
vector<func> callCommand;
void Running()
{
cout << "Running now" << endl;
}
void Writing()
{
cout << "Writing now" << endl;
}
void Eating()
{
cout << "Eating now" << endl;
}
void Sleeping()
{
cout << "Sleeping now" << endl;
}
void Testing()
{
cout << "Testing now" << endl;
}
void CommandInit()
{
callCommand.push_back(Running);
callCommand.push_back(Writing);
callCommand.push_back(Eating);
callCommand.push_back(Sleeping);
callCommand.push_back(Testing);
}
void ShowAllCommand()
{
//... if you want you can write one ^-^
}
#include<cstdlib>
#include<iostream>
#include<cstdio>
#include<vector>
#include<unistd.h>
#include<sys/wait.h>
#include<sys/fcntl.h>
#include<assert.h>
#include"Command.h"
using namespace std;
#define PROCESS_NUM 5 //number of process is 5
int main()
{
CommandInit(); //init for Command function
vector<pair<pid_t, int>> KvPidFd; //record children process pid & read file fd
for(int i = 0; i < PROCESS_NUM; i++) //creat child process
{
int pipefd[2] = { 0 };
int k = pipe(pipefd);
assert(k == 0); //-1 : creat false
pid_t id = fork();
if(id == 0) //child
{
close(pipefd[1]);
while(1)
{
uint32_t accept = -1; //uint32_t : unsigned int in 32bit
cout << "*********" << getpid() << endl;
int s = read(pipefd[0], &accept, sizeof accept);
if(s == 0) break; //if s is zero, that's mean child read zero word in pipe
assert(accept >= 0);
cout << "I am child " << getpid() << " now accept command : ";
callCommand[accept](); //invoke function
}
cout << "child " << getpid() << "finished work !" << endl;
close(pipefd[0]);
exit(0);
}
//only father process can go to this step
//take chiid pid & it's write fd as a mapping
close(pipefd[0]);
KvPidFd.push_back(make_pair(id, pipefd[1]));
}
srand((unsigned int)time(nullptr) * getpid() * 131);
uint32_t command = 0;
int proc = -1;
int count = 0;
while(1) //father
{
sleep(1);
//random distribute function which will be commanded
command = rand() % callCommand.size();
assert(command >= 0);
proc = rand() % PROCESS_NUM; //random distribute process which will be used
assert(proc >= 0);
write(KvPidFd[proc].second, &command, sizeof(command));
count++;
if(count == 5) break;//stop this loop when calling child five times
}
//close pipe files & revoke children
for(auto kv : KvPidFd)
{
close(kv.second);
}
for(auto kv : KvPidFd)
{
waitpid(kv.first, nullptr, 0);
}
return 0;
}
（三）.进程池管道陷阱
有人可能有疑惑，这里有什么陷阱呢？
嗯。。如果父进程在关闭写端管道同时关闭相应子进程呢？
看似没有问题？
//close pipe files & revoke children
for(auto kv : KvPidFd)
{
close(kv.second);
pid_t id = waitpid(kv.first, nullptr, 0);
assert(id > 0);
cout << "From father : child " << id << "finish work" << endl;
}但是程序直接夯住了！
不要着急，我们来仔细梳理一下父进程与子进程的管道关系就能得到答案。
当父进程创建子进程1前，先创建了管道1，子进程1与父进程的fd_array都会记录管道1的fd。
当父进程创建子进程2前，先创建了管道2，子进程2与父进程fd_array都会记录管道2的fd。但是，子进程2的fd_array中也会记录管道1的fd。
是的，后面创建的子进程不仅会记录自己管道的fd，也会记录之前创建的管道fd，准确来讲是继承之前管道的写端。
于是，当父进程关闭管道写端后，管道写端并没有被全部关闭，read函数会一直阻塞，进而根本无法执行到waitpid的步骤。
因此，只有将父进程所有管道的写端都关闭后，首先是最后创建的子进程完成read返回0的操作，因为对它而言，有它管道的写端的只有父进程。当最后一个子进程关闭后，倒数第二个开始关闭，...直到第一个关闭。
所以，我们这是使用关闭管道和回收子进程分开的方式进行。
图示如下：
如果你是房间里最聪明的人，那么你走错房间了——未名
如有错误，敬请斧正