当管道创建失败的时候，进行报错，并且显示错误码和错误信息。

可以看到，创建管道后返回的两个fd值，果然是3和4，因为0,1,2分别被stdin，stdout，stderr占用。

知道了如何使用系统调用创建管道以后，接下来就创建子进程，然后关闭不需要的端口了，原理已经清楚，直接看代码。

为了方便，我们让父进程进行读，子进程进行写。

• 子进程第一件要做的事情就是关闭读端。
• 父进程在创建好子进程以后，第一件要做的事情就是关闭写端。

此时在代码层面上， 父子双方就已经建立了连接了，接下来就是通信数据了。

通信代码及演示

子进程通信代码：

将上面子进程通信代码处的sleep(5)换成如上图所示代码。每隔一秒钟，子进程向父进程发生一个字符串，包括子进程的pid，以及发送次数。

• 为了保证通信的正确，使用snprintf来严格控制发送数据，将数据写入到buffer中。
• 向管道中写入，使用的是系统调用write。

父进程通信代码：

• 向管道中读取，使用的是系统调用read。

父子进行通信现象：

每隔一秒，父进程读取一次管道中的数据。

匿名管道的读写特征

1. 读慢，写快

• 子进程循环不停向管道中写入数据。
• 每写入一次会打印一句写入完成，并且打印出子子进程的pid。

• 父进程只读取一次
• 读取完成后阻塞不动,1000s后再读取一次

此时就模拟出了，向管道中写入非常快，而从管道中读取则很慢，每隔1000读取一次。

• 子进程在快速的多次写入以后就不动了，因为管道此时已经被写满了，所以子进程状态是S+，处于阻塞状态。
• 父进程由于在sleep，也处于是阻塞，读取一次管道数据后就没有再读取。

根据上面现象可以看出，管道中的数据没有被读取端读走时，写入端在将管道写满以后会停止写入，为了防止管道中的数据被覆盖。

结论：写入快，读取慢，write调用阻塞，直到有进程读走数据。

2. 读快，写慢

• 子进程写入一次后延时1000s，阻塞不动。

• 父进程快速读取，没有时间间隔。
• 在读取之前打印开始读取，读取之后打印读取结束。

此时就模拟出，读取快，写入慢的场景。

• 子进程向管道中写入一次后延时阻塞不动。
• 父进程将子进程一次写入到数据完整读取，如上图中红色框所示。
• 父进程在进行第二次读取的时候，只打印了开始读取，没有读取结束，阻塞在了读取处，如上图中绿色框所示。

根据上面现象可以看出，写入端没有向管道中写入数据的时候，读取端会阻塞，等待数据写入然后再读取。

结论：写入慢，读取块，read调用阻塞，即进程暂停执行，一直等到有数据来到为止。。

3. 写入端关闭，读取端未关闭

• 子进程每隔一秒向管道中写入一次数据。
• 写入十次以后停止写入，并且关闭子进程的写端。

• 父进程不停的从管道中读取数据。
• 当read返回值为0的时候，表示读到了文件结尾，也就是管道中数据读完了，并且不会再有了。
• 此时停止读取，并且关闭读端。

• 子进程写入十次后，关闭写端。
• 父进程中read的返回值为0，并且不会阻塞在read处。

根据上面的现象，当管道的写入端关闭时，读取端也就没有等待的打开的必要了，所以read就会返回0，表示管道的写入端已关闭。

结论：管道写端对应的文件描述符被关闭，则read返回0。

4. 写入端未关闭，读取端关闭

• 子进程隔一秒向管道中写入一次，一只重复。

• 父进程读取10次，然后关闭读端。
• 再进行进程等待，并且查看子进程的退出信号。

• 父进程读取10次以后，关闭读端。
• 进程等待子进程，子进程的进程结束信号是13.
• 信号13是一个管道信号，具体是什么以后再说。

根据上面现象，当管道的读取端关闭后，操作系统会自行结束管道的写入端，因为此时写入端的存在已经没有意义了。

结论：管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE，让write进程退出。

总结一下管道的读取特征：

管道之所以有这样的读取特征，其实是为了对管道中的数据进行保护，这种方式称为互斥，后面本喵会详细讲解这一概念。

匿名管道本身也有它自己的特征，如下：

• 管道的生命周期随进程的结束而结束，当所有进程都关闭该管道的文件描述符时，管道被销毁。
• 管道可以用来进行具有血缘关系的进程之间进行通信，常用于父子进程通信。
• 管道是半双工的通信方式
• 管道是面向字节流的(在网络部分讲解)。
• 管道有互斥与同步机制对共享资源进行保护(以后讲解)。

⭐命名管道

• 命名管道：顾名思义，有名字的管道(内存级文件)。

根据前面的学习，我们知道，父子进程间使用匿名管道的方式进行通信，是通过子进程继承父进程的方式来实现，而且匿名匿名管道常用于父子进程直接，或者由血缘关系的进程直接。

那么，如果两个进程毫无关系呢？此时就不能继承了，那这两个进程如何建立连接呢？

还是采用管道的方式，但是这个管道是有名字的管道，这样一来，两个进程就可以打开同一个管道文件建立连接。

还是这张图，此时内存中的struct file在磁盘上有对应文件的，如上图中的fifo.ipc文件。

• 指令：mkfifo 文件名
• 功能：创建命名管道文件

如上图所示，此时就创建了一个命名管道，可以看到，文件类型是p，而且该文件还有inode，说明在磁盘上是真实存在的。

当磁盘中有了命名管道文件以后，两个进程将可以通过这个管道文件进行通信了，步骤和匿名管道非常相似。

• 一个进程以写方式打开管道文件。
• 另一个进程以读端方式打开管道文件。

此时两个进程将建立了连接，然后将可以进行通信了。

我们知道，进程间通信的前提是，要通信的进程能够看到同一份公共资源，那么命名管道是如何做到这一点的呢？

• 让不同的进程打开指定路径下同一个管道文件。

路径 + 文件名 = 唯一性

所以说，命名管道是通过利用这种唯一性来让要通信的进程都看到这块内存级文件的。

命名管道的系统调用mkfifo/unlink

创建管道文件：
可以在shell中通过命令的方式创建管道文件，两个进程直接去使用它。也可以像文件一样，在进程中创建管道文件，此时就需要用到系统调用。

• 第一个形参：管道文件的名字
• 第二个形参：创建管道文件的权限
• 返回值：0表示创建成功，-1表示创建失败。

为了使用方便，将创建管道文件的步骤封装在一个函数中。

• 虽然管道文件属于公共资源，并且是由操作系统维护的。
• 但是它也得有人去创建。通信双方必须有一方创建管道文件，

此时就有了这样一个管道文件，结果和使用命名mkfifo的结果是一样的。

再次运行程序，就会报错，管道文件已经存在，所以说，如果管道文件已经存在了，就没有必要再使用系统调用mkfifo。

删除管道文件：

向管道文件中写如数据，这些数据是不会IO到磁盘中的。

管道文件的大小为0，说明此时文件中是没有内容的。

向管道文件中疯狂写入数据。

让程序开始疯狂向管道文件中写入内容，再查看管道文件，发现文件的大小没有变化。

和匿名管道一样，向命名管道写文件时，不会和磁盘进行IO，而是将数据写到了struct file结构体的缓冲区中，数据写入了内核中。

• 这样看来，命名管道文件我们能不能看到不重要。
• 可以在使用完管道文件以后，再将管道文件删除。

• 形参：要删除的管道文件名称(路径加名字)
• 返回值：删除成功返回0，失败返回-1。

在管道文件的维护方，当使用完毕后，将管道文件删除。

此时在完成通信以后，我们也不会看到管道文件，它的创建与删除都由通信的某一方来维护。

通信代码及演示

我们创建两个进程进行通信，一方叫做sever，另一方叫做client，sever负责创建管道文件，并且从管道中读取数据，client负责向管道中写入数据。

sever.c代码：

创建好管道文件以后，使用系统调用open以写的方式打开文件，再通过系统调用read读取管道中的数据。

client.c代码：

在server.c创建好管道文件以后，再使用open以写方式打开管道文件，再通过write将从键盘上获取的数据写入到管道文件中。

运行效果：

client输入什么，sever就输出什么，此时两个无关的进程就成功进行了通信。

• 必须先运行sever，再运行client，因为sever要创建管道文件，只有管道文件创建了以后才有进行通信的前提。

有了匿名管道的基础，命名管道就很简单了，不同之处只在于需要创建管道文件和打开管道文件，而匿名管道的pipe系统调用直接就将管道文件创建好并且打开了。其他的操作都一样。

命名管道读写特征

命名管道和匿名管道在那4个方面的读写特征是完全一样的，也是存在互斥机制的。除此之外还有一些其他的特点。

1. 读端要打开，写端未打开

• 在读端代码中，在open操作前后分别打印一句话。
• 只执行server(读端)，不执行client(写端)。
• 只有读端要打开管道文件，写端不打开。

根据现像，此时server不再执行了，阻塞在了这里。

结论：当读端要打开管道，而写端没有打开时，会在读端的open处阻塞。

2. 写端要打开，读端未打开

• sever端在创建文件后进行1000s延时，阻塞在这里。

• 在写端open前后各打印一句话。

根据现象，写端执行到open打开管道文件的时候阻塞了。

结论：当写端要打开管道，而读端没有打开时，会在写端的open处阻塞。

总的来说，进行通信的双方，一方没有打开管道文件，另一方在打开的时候就会阻塞在open处。

除了读写时的特征，命名管道本身也有特征：命名管道的生命周期随内核。
我们可以看到，管道文件是可以直接在磁盘上存在的，和进程无关，这一点和命名管道不一样，其他的特征都一样。

匿名管道和命名管道的区别：

• 匿名管道由pipe函数创建并打开。
• 命名管道由mkfifo函数创建，打开用open，删除用unlink函数。
• FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。

🌞进程池(小练习)

现在对管道已经有了一定的认识，下面喵给大家用匿名管道写一个进程池的小项目。

• 如上图所示，一个父进程创建多个子进程，父进程和每个子进程之间通过管道相连接。
• 子进程按照父进程发生过来的命令码执行相应的认为。

1. 创建子进程及对应管道，并且维护通信关系

• 创建子进程和管道

在循环中，每次都先创建匿名管道，然后再创建子进程，让子进程继承父进程对匿名管道读写端的文件描述符fd。

• 子进程处理

子进程要做的第一件事情就是关闭对匿名管道写端的文件描述符fd。然后再执行具体的代码(后面再讲解具体怎么执行)。当每一个子进程执行完代码后，关闭对应的读端文件描述符fd，再进程退出。

• 父进程保存子进程信息

父进程在创建好子进程后，第一件要做的事情就是关闭对应管道的读端文件描述符fd，然后再保存子进程的相关信息，方便后面进行控制。

要保存的子进程信息：

• 首先就是子进程的pid，方便后面进行进程等待等操作。
• 再就是和子进程通信管道的写端描述符fd，方便后面进行写数据。
• 其次就是子进程的名字信息，这个是我们自己为了观察现象而设置的。
• 还有就是子进程的编号，也就是计数器。

为了方便描述子进程的信息，我们创建一个结构体来描述子进程。

然后将子进程的信息对象放在vector中，这样就组织了起来，方便我们进行管理。

先描述再组织的思想。

2. 父进程控制子进程

• 任务制定

先制定一批让子进程执行的任务。

本喵这里粗略写了五个任务，如上图所示，每一个任务实际上就是一个函数。

为了方便管理这些任务，同样需要将它们组织起来。

//定义函数指针
typedef void(*func)();

将函数指针类型typedef为func。

然后将这些任务都放在vector中管理起来，此时vector的每一个元素都是一个任务的函数指针，而元素的下标就是子进程要接收的任务码。

• 分配任务

之所以让多个进程来执行任务，就是为了充分利用系统资源，提高效率，如果在一个子进程完成任务的期间，其他子进程在等待那就失去了意义。

• 为了同时调度所有子进程，并且完成多种任务，采取随机指定子进程和随机指定任务的方式。

//获取随机数种子
#define MakeSeed() srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123456 ^ rand() % 123)

首先生成随机数种子，种种子的方法很多，本喵只是随意写了一下。

• 父进程给指定子进程发送任务码

使用系统调用write向匿名管道中写入命令码，对应的管道的写端文件描述符从类对象中获取，在创建的时候就保存了。

命令码就是存放函数指针的vector的下标，是int类型的整数，要严格控制写入管道的字节数，防止通信发生意外。

• 任务执行完毕

如果执行的任务次数是有限次的，当任务被这些子进程执行完毕以后，需要关闭所有的写端描述符fd。这里存在潜在问题，一会儿详细讲解，但是不影响我们使用。

3. 子进程执行任务

这部分代码在维护父子进程通信关系时出现过，现在本喵介绍下子进程执行任务的具体流程。

• 接收命令码

使用系统调用read从匿名管道中读取父进程发来的命令码，并且严格检查是否是4个字节，如果是说明接收正确，返回命令码，如果不是，返回-1。

• 执行任务

根据接收到的命令码，从存放函数指针的vector中找到对应的函数指针，调用对应的函数。

4. 回收子进程资源

当所有任务被完成以后，父进程关闭所有管道的写端，子进程接收到的命令码就会是-1，然后子进程就会退出。

当父进程关闭写端以后就会进程等待，每等待成功一个子进程都会打印一句话，当所有子进程被等待成功后父进程退出。

5. 潜在问题

• 问题描述

上面在关闭所有的写端描述符时，本喵提到存在潜在问题，下面来分析一下：

• 父进程的文件描述符表中存在一个管道的文件描述符，如上图所示的3。
• fork出子进程后，会继承父进程的文件描述符表，再加上自己的文件描述符fd，此时的文件描述符表中就有两个fd，如上图所示的3和4。

• 当父进程创建多个子进程时，就会创建多个管道，每增加一个子进程就会增加一个管道以及文件描述符fd。
• 子进程又会继承父进程的文件描述符，尤其是最后一个创建的子进程，文件描述符表中有很多的fd，但是只有最后一个是属于自己和父进程通信的。

此时问题就来了，当父进程关闭一个写端文件描述符fd的时候，这个管道被关了码？

• 很显然没有被关，因为子进程的文件描述符表中仍然有fd执行父进程关闭的管道。

我们的程序中，之所以没有出问题，是因为将父进程的所有写端被关闭时，所有的子进程对应那个管道的read会读取到0，然后子进程就会退出，它维护的文件描述符表也就销毁了，当所有文件描述符表被销毁后，就没有fd指向管道了，管道也就被回收了。

• 解决问题

为了避免这个问题，每个子进程在创建后，不仅要关闭写端描述符，还要关闭从父进程继承下来的文件描述符fd。

专门创建一个vector，用来存放要被子进程删除的从父进程继承下来的写端fd。

• 在父进程保存子进程信息的时候，将父进程的写端fd放入到专用的删除vector中。
• 在子进程中，关闭vector中所有内容所对应的文件描述符fd，此时子进程的文件描述符表中就只剩下自己和父进程通信所用管道的fd了。

至此，我们进程池的代码就完美了。

⭐效果展示

本喵这里是创建了5个子进程，需要完成10次随机任务。

也可以用命名管道实现，只是需要由某一个进程负责创建命名管道文件和删除。要通信的其他进程也不用fork，需要自己写具体的进程，有兴趣的小伙伴可以自行尝试。

⭐附源码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include /****************************************用到的定义***************************************************/
#define PROCESS_NUM 5
//获取随机数种子
#define MakeSeed() srand((unsigned int)time(nullptr) ^ getpid() ^ 0x123456 ^ rand() % 123)//定义函数指针
typedef void(*func)();class subInfo
{
public://构造函数subInfo(pid_t subid,int wfd):_subid(subid),_wfd(wfd){char nameBuffer[1024];snprintf(nameBuffer,sizeof(nameBuffer),"子进程(%d)[pid(%d),fd(%d)]",_num,_subid,_wfd);_name = nameBuffer;_num++;}
public:static int _num;//子进程数量std::string _name;pid_t _subid;//子进程pidint _wfd;//子进程对于管道写端fd
};//域外初始化static变量
int subInfo::_num = 0;/****************************************子进程要完成的任务***************************************************/
void downLoadTask()
{std::cout<<"我是子进程，pid："<std::cout<<"我是子进程，pid："<std::cout<<"我是子进程，pid："<std::cout<<"我是子进程，pid："<std::cout<<"我是子进程，pid："<& funcMap)
{funcMap.push_back(downLoadTask);funcMap.push_back(ioTask);funcMap.push_back(flushTask);funcMap.push_back(netTask);funcMap.push_back(dealTask);
}/****************************************进程池核心代码***************************************************/
//子进程接收任务码
int recvTask(int rfd)
{int code = 0;ssize_t ret = read(rfd,&code,sizeof(int));if(ret==4) return code;else if(ret <=0 ) return -1;//读取出错else return 0;
}//父进程发生任务码
void sendTask(const subInfo& proc,int taskIdx)
{std::cout<<"--------------------------------------------------"<& subs,const std::vector& funcMap)
{std::vector deleteFd;for(int i = 0; i < PROCESS_NUM; ++i){//创建匿名管道int fds[2];int ret = pipe(fds);assert(ret==0);(void)ret;//创建子进程pid_t id = fork();/******************子进程**************************/if(id == 0){//子进程进行读，关闭写端close(fds[1]);//删除继承自父进程的写端描述符for(int i = 0;i < deleteFd.size();++i){close(deleteFd[i]);}//子进执行代码while(1){//读取命令码int commandCode = recvTask(fds[0]);//执行任务if(commandCode >= 0 && commandCode < funcMap.size()){funcMap[commandCode]();}else if(commandCode == -1) break;}//子进程退出，关闭读端close(fds[0]);exit(0);}/******************父进程**************************///父进程进行写，关闭读端close(fds[0]);//保存子进程pid，对应管道的fdsubInfo sub(id,fds[1]);subs.push_back(sub);//保存子进程要删除的写端fddeleteFd.push_back(fds[1]);}
}//负载均衡控制
void loadBalanceContral(const std::vector& subs,const std::vector& funcMap,int taskCount)
{int procesNum = subs.size();int taskNum = funcMap.size();bool forever = (taskCount == 0 ? true : false);while(1){//选择子进程int subIdx = rand()%procesNum;//选择任务int taskIdx = rand()%taskNum;//将任务发生给子进程sendTask(subs[subIdx],taskIdx);sleep(1);if(!forever){taskCount--;if(taskCount == 0) break;}}//任务执行完成，关闭所有写端for(int i = 0;i < procesNum;++i){close(subs[i]._wfd);}
}//回收子进程信息
void waitPorcess(std::vector& subs)
{int procesNum = subs.size();for(int i = 0;i < procesNum;++i){int ret = waitpid(subs[i]._subid,nullptr,0);assert(ret == subs[i]._subid);std::cout<<"子进程等待成功，pid："<MakeSeed();std::vector subs;std::vector funcMap;loadTaskToMap(funcMap);//创建子进程，维护通信关系createSubProcess(subs,funcMap);//父进程控制子进程int taskCount = 10;loadBalanceContral(subs,funcMap,taskCount);//回收子进程信息waitPorcess(subs);return 0;
}

🌞总结

在实际应用中，匿名管道的使用比命名管道要多，而且只有掌握了匿名管道，命名管道可以说是手到擒来，很容易。进程池的小项目对理解匿名管道非常的有帮助。