linux进程间通信——匿名管道、简易进程池、pipe应用

        前言：本节内容主要是关于管道的应用。 博主将会先谈管道在我们学习中的应用， 然后会实现一个进程池， 来更好的理解管道。本节内容很少原理， 都在实现代码。 对于友友们的进程控制能力有很大的考验！！！

        ps：本节内容建议友友们了解进程控制， 了解管道的相关概念特性以及情况再来观看！

目录

 "|"和管道的关系

池化技术

简易进程池的实现

创建文件

准备makefile

描述管道

 管道的再组织与创建框架

创建管道

 创建任务列表

 控制子进程

  子进程核心代码——执行任务

清理进程

重谈创建管道

全部代码

---

 "|"和管道的关系

        我们看一下cat test.txt | head -10 | tail -5这串指令， 我们说过， 我们在命令行输入的这个竖画线其实就是管道， 和我们今天学的pipe有没有什么关系呢？ ——答案是有关系。

当我们用管道链接起这几个命令的时候， 其中每一个对应的命令， 都会被直接启动成进程， 这三个进程对应的PPID都是同一个。 这里叫作32310， 现在我们ps axj看一下32310是哪个进程：

        PID是32310的进程就是bash， 并且我们能够看到， 这三个进程的PID相邻， 所以这三个进程的关系就是具有血缘关系！！！

        上面我们的命令中有两个竖画线， 那么在命令行解释的时候， 就先将我们的两个竖画线解释成管道， 然后连续创建三个进程， 程序替换后执行不同的命令。 在执行之前我们可以对每一个进程的标准输出， 标准输入进行重定向。 因为每一个管道都有自己的输出和输入。 既然文件的描述符可以重定向， 那么管道也可以重定向。 那么我们就能直接串联起这几个命令， 让他们通信起来。 ——所以， 我们以前在命令行上使用的这个“|”本质上就是pipe。

池化技术

        在我们使用c/c++， 用new， malloc的时候， 其实一定会调用系统调用接口！今天我和操作系统要5个字节， 明天要10个， 后天要30个。 这个过程那么我们就调用了三次系统调用。 那么我们如果向系统直接要100个字节的空间， 或者200字节的空间， 然后我们要了之后， 我们以后申请内存的话就不用系统调用了。 等到用的时候直接在这个200字节的空间里拿就可以了。 ——因为系统调用也是有成本的， 这个成本体现在它可能会在调用的时候，这个时候操作系统却在做着别的事情， 需要等待， 导致效率降低。 

        原本呢， 父进程就是创建子进程， 然后子进程退出的时候进行等待， 退出程序。 但是呢， 我们每一次创建子进程， 拷贝task_struct， 拷贝页表， 都有很高的成本。 ——在操作系统层面上是一个很低效的操作。 所以， 父进程能不能先把一批进程创建好， 当有任务到来时， 我直接将任务指派给其中一个进程。 其中， 我们一次把对应的一批进程创建好， 这个工作就叫做进程池的储备。 也就是把一个一个的进程当作一分一分的资源， 提前储备好， 当我们需要的时候， 再帮我们去分配这些任务。

简易进程池的实现

        知道了上面的池化技术之后， 我们可以来实现一个简单的进程池。 这个进程池的大致图如下:

        其中， 父进程想要向哪个管道里写内容， 就可以向其中写内容。 我们的父进程， 如果没有向其中写任何内容， 那么请问这个时候子进程在干什么？ 这个子进程因为读不到任何内容， 所以他就在等待， 那么子进程就阻塞在这个管道当中。 如果父进程写了， 那么子进程就会读到这个数据，继续向后执行。 那么结合读进来的数据和向后执行的动作， 我们的子进程就可以去执行对应的任务了。——所以， 我们规定， 我们的父进程向管道里写的，都是一个一个的任务码。 我们规定好， 父子通信时， 父进程每次写入时最多只能写四个字节。规定好，子进程在读取的时候， 也只能读取四个字节。 ——知道了这些， 我们就可以着手实现建议的进程池了！！

ps:博主在这里实现的管道是父进程为写入端， 子进程为读端！        

创建文件

先创建需要的“老三样”

准备makefile

先将我们的makefile准备好。 指令如下——这里不做解释， 不会的友友请自行学习makefile工具的使用：

ProcessPool.exe:ProcessPool.cpp
	g++ -o $@ $^ -std=c++11

.PHONY:clean
clean:
	rm -rf ProcessPool.exe

描述管道

        我们为了创建进程池， 就势必要管理管道， 控制进程。——为什么？ 因为对于进程池来说， 每一个进程都有一个管道与它联系起来。 而里面的进程是有多个的， 对应的管道就要有多个。 既然管道有多个， 那么我们为了这些管道能够”听话“， 就必须将他们管理起来， 而如何管理？ ——先描述， 再组织。 所以， 这里先描述管道：

先将ProcessPool.h里面包含好头文件

#include<iostream>
using namespace std;

#include<string>

再在ProcessPool.cpp里面描述管道 

#include"ProcessPool.h"

class channel
{
public:
    channel(int cmdfd, pid_t slarverid, string processname)
        :_cmdfd(cmdfd)
        ,_slarverid(slarverid)
        ,_processname(processname)
    {}
    
public:
    int _cmdfd; //文件描述符: 表示父进程的连接某个管道的fd是多少
    pid_t _slarverid;   //表示管道的连接的子进程的PID
    string _processname; //管道连接的子进程的名字
};

 管道的再组织与创建框架

在我们的ProcessPool.h文件里面包含一下

#include<iostream>
using namespace std;

#include<string>
#include<vector>

然后是ProcessPool.cpp里面的代码 , 这里面， vector<channel> channels其实就是一个再组织的过程。

#include"ProcessPool.h"

class channel
{
public:
    channel(int cmdfd, pid_t slarverid, string processname)
        :_cmdfd(cmdfd)
        ,_slarverid(slarverid)
        ,_processname(processname)
    {}
    
public:
    int _cmdfd; //文件描述符: 表示父进程的连接某个管道的fd是多少
    pid_t _slarverid;   //表示管道的连接的子进程的PID
    string _processname; //管道连接的子进程的名字
};

//创建管道函数
void InitProcess(vector<channel>* channels)
{

}

//控制子进程
void CtrlSlaver(vector<channel>& channels)
{

}


//清理收尾
void QuitProcess(vector<channel>& channels)
{

}

int main()
{
    //再组织的过程
    vector<channel> channels;


    //创建管道
    InitProcess()

    //控制子进程
    CtrlSlaver();

    //清理收尾
    QuitProcess();

    return 0;

    return 0;
}

创建管道

在创建管道之前， 我们要先定义一个全局的常量， 用来规定我们要创建多少个子进程

const int processnum = 5; //五个子进程

InitProncess是创建管道代码块。需要注意的是这里面有一个Slaver函数， 这个函数是子进程的核心代码块， 子进程的读取， 执行等操作都是在这个模块里面执行。

//创建管道函数
void InitProcess(vector<channel>* channels)
{

    for (int i = 0; i < processnum; i++)
    {
        //创建管道
        int pipefd[2];
        int n = pipe(pipefd);  //创建一个管道， 并且父进程的读写端都指向这个管道
        if (n != 0) exit(0); //如果创建失败， 直接退出进程
        
        //创建子进程
        pid_t id = fork(); //创建子进程
        if (id == 0)       //执行子进程模块 
        {
            close(pipefd[1]);    //子进程用来读， 所以要关闭子进程的写端
            //核心代码
            dup2(pipefd[0], 0);  //将0号描述符作为读端描述符，（其实这里不用dup2也可以， 博主也不知道这段代码段作用） 但是这么设计是为了更规范，这是一种设计方式
            slaver(); //核心代码

            exit(0);   
        }
        close(pipefd[0]);

        string name = "process-" + to_string(i);
        channels->push_back(channel(pipefd[1], id, name));  //将数据保存到channels；

    }
}

 创建任务列表

首先在ProcessPool.h文件里面定义一下要创建的函数

#include<iostream>
using namespace std;

#include<string>
#include<vector>

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

void task1();

void task2();

void task3();

void task4();

void LoadTask(vector<task_t> *tasks);  //定义加载函数

        然后在我们的ProcessPool.cpp里面将函数实现好； 并且我们要定义一个全局的vector数组， 元素类型是task_t, 这个vector数组用来保存我们要执行的任务。 ——如何保存？ LoadTask函数就是这个作用！！！下面为代码:

#include"ProcessPool.h" 
const int processnum = 5; //五个子进程

//任务执行， 这里使用lol的例子
void task1()
{
    cout << "lol 刷新日志" << endl;
}

void task2()
{
    cout << "lol 更新野区" << endl;
}
void task3()
{
    cout << "lol 检测软件是否更新， 如果需要就提示用户" << endl;
}
void task4()
{
    cout << "lol 用户释放技能 更新用户的技能和血量" << endl;    
}

void LoadTask(vector<task_t> *tasks)
{
    tasks->push_back(task1);
    tasks->push_back(task2);
    tasks->push_back(task3);
    tasks->push_back(task4);
}

vector<task_t> tasks;



//………………
//………………中间为创建管道， 控制子进程， 清理收尾等函数，这里省略
//………………



int main()
{
    LoadTask(&tasks); //程序打开时就将tasks准备好
    

    //再组织的过程
    vector<channel> channels;


    //创建管道
    InitProcess()

    //控制子进程
    CtrlSlaver();

    //清理收尾
    QuitProcess();


    return 0;
}

 控制子进程

先实现一个menu函数

void menu()
{
    cout << "*****************************************" << endl;
    cout << "******  1.更新日志      2.更新野区   ******" << endl;
    cout << "******  3.检测更新      4.释放技能   ******" << endl;
    cout << "******  0.退出                      ******" << endl;
    cout << "*****************************************" << endl;
}

        控制子进程的时候我们要想一下， 我们是不是要选择一个子进程？ 是不是还要向管道里写一个任务码？ 然后被选中的子进程从管道里拿到任务码， 再根据任务码知道vector<task_t>里面的task任务，就可以执行相应的任务了。

//控制子进程
void CtrlSlaver(vector<channel>& channels)
{
    int which = 0;
    int select = 0;

    while(true)
    {
        //1.选择任务， 选择进程
        menu();

        //输入选择，选择执行的任务
        cin >> select;
        if (select <= 0 ||  select >= tasks.size()) break;  //判断select是否合法, 不合法就退出
        int cmdcode = select;
        //
        //2.选择进程
        int processpos = which;  //选择进程使用轮询法， 就是使用which;
        
        write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode)); //第一个参数为fd输入性参数， 第二个参数为cmdcode要写入的首地址， 
        which++;
        which %= channels.size();

        sleep(1);
    }
}

  子进程核心代码——执行任务

子进程的核心代码就是Slaver函数， 这个函数里面我们主要实现的功能是读取管道里面的数据， 而子进程的读端是0号fd， 所以我们就要设置一个cmdcode的变量， 然后将管道内的数据读到里面。——但是问题又来了， 读取的时候我们要循环读取， 那么循环读取需不需要sleep防止子进程疯狂读取呢？——答案是不需要， 因为我们的管道具有协同的特性， 当读写端正常， 并且管道没有数据的时候， 读端会阻塞等待！！！！

void Slaver()
{
    int cmdcode = 0;
    while (true)
    {
        int n = read(0, &cmdcode, sizeof(cmdcode));    //read返回的是读取到的字节的个数。 
        //然后第二个参数是要读到哪里去， 第三个参数是读取的大小,这一行代码执行完后， cmdcode里面保存的就是要执行的任务码

        if (n == sizeof(cmdcode))
        {
            cout << "slaver get a command : " << getpid() << " : " << "cmdcode" << cmdcode << endl;
            if (cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();
        }
        if (n == 0) break; //如果读到0， 说明写端关闭， 读端读到文件末尾， 就需要停止读取了
        
        cout << "Process PID: " << getpid() << "quit" << endl;
    }
}

清理进程

在我们上面创建管道的代码其实有一个小bug，我们创建的管道其实是这样的：

        在我们创建第一个进程的时候， 父进程除了默认的三个0,1, 2文件描述符没有别的，创建新的文件描述符3, 和4后， 子进程拷贝， 也是3， 和4， 并且父进程关闭3， 子进程关闭4. 

        但是在创建第二个子进程的时候， 我们的父进程除了三个0， 1， 2默认的文件描述符外， 我们的父进程还有一个4号写端。 然后创建新的文件描述符3和5， 子进程拷贝后就是有0， 1， 2， 3， 4， 5，号文件描述符。 父进程关闭3，子进程关闭5. 那么子进程剩下的就是0， 1， 2， 3， 4，文件描述符。 其中3号里面就是我们要的读端的指针，而5号其实是指向管道的写端的指针！！！

就是下图        那么最后就会造成除了最后一个创建的管道， 其他的管道不是只有一个写端。 假如一共有5个管道， 那么每隔管道从先创建到后创建就是有5, 4, 3, 2, 1个写端。

         这就有什么问题？ ——先不谈写入时候的问题（博主没有验证出来）， 但是就对于清理来说就会有影响的。 ——在我们的设想中， 每一个管道是只有一个读端一个写端的。 那么当我们清理子进程的时候就可以使用情况读端正常， 写端关闭， 读端会读取0个字节。 相应的read的返回值就是0， 那么我们加一层判断。 if (n == 0) ， 就直接exit退出子进程, 父进程等待就可以了。那么这个代码就是如下:

void QuitProcess(const vector<channel> &channels)
{
    for (const auto e : channels) 
    {
        close(e._cmdcfd);  //写端
        waitpid(e._slarverid, nullptr, 0);
    }
}

        但是这样，很明显是不行的。 因为我们的管道不只是一个写端。 关闭父进程的写端后， read并不会返回0， 所以子进程就退出不了！！！（除非从后向前关闭写端， 这里不做演示， 友友们有兴趣可以自己实验）——那么怎么处理这个问题呢？ ——这里我们要从创建管道的板块进行修改！！！

重谈创建管道

我们设计如下三行代码就可以解决上面的问题:

下面是创建管道的代码:

//创建管道函数
void InitProcess(vector<channel>* channels)
{
    vector<int> oldfds; //创建一个数组， 用来保存父进程占用的文件描述符
    for (int i = 0; i < processnum; i++)
    {
        //创建管道
        int pipefd[2];
        int n = pipe(pipefd);  //创建一个管道， 并且父进程的读写端都指向这个管道
        if (n != 0) exit(0); //如果创建失败， 直接退出进程
        
        //创建子进程
        pid_t id = fork(); //创建子进程
        if (id == 0)       //执行子进程模块 
        {
            for (auto fd : oldfds) close(fd);   //遍历整个数组， 将已经占用的文件描述符关闭。
            close(pipefd[1]);    //子进程用来读， 所以要关闭子进程的写端
            //核心代码
            dup2(pipefd[0], 0);  //将0号描述符作为读端描述符，（其实这里不用dup2也可以， 博主也不知道这段代码段作用） 但是这么设计是为了更规范，这是一种设计方式
            Slaver(); //核心代码

            exit(0);   
        }
        close(pipefd[0]);
        string name = "process-" + to_string(i);
        channels->push_back(channel(pipefd[1], id, name));  

        oldfds.push_back(pipefd[1]); //记录当前父进程的pipefd[1]里面的占用的文件描述符
    }
}

全部代码

上面的做好了之后， 就实现了简单的进程池。 下面是我们的代码:

ProcesssPool.h文件：

#pragma once
#include<iostream>
#include<cstdio>
using namespace std;
#include<string>
#include<vector>
#include<unistd.h>
#include<stdlib.h>
#include<cassert>
#include<sys/stat.h>
#include<sys/wait.h>

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

void task1();


void task2();

void task3();

void task4();


void LoadTask(vector<task_t> *tasks);  //定义加载函数

ProcessPool.cpp文件

#include"ProcessPool.h" 
const int processnum = 5; //五个子进程



//

vector<task_t> tasks;

class channel
{
public:
    channel(int cmdfd, pid_t slarverid, string processname)
        :_cmdfd(cmdfd)
        ,_slarverid(slarverid)
        ,_processname(processname)
    {}
    
public:
    int _cmdfd; //文件描述符: 表示父进程的连接某个管道的fd是多少
    pid_t _slarverid;   //表示管道的连接的子进程的PID
    string _processname; //管道连接的子进程的名字
};


void Slaver()
{
    int cmdcode = 0;
    while (true)
    {
        int n = read(0, &cmdcode, sizeof(cmdcode));    //read返回的是读取到的字节的个数。 
        //然后第二个参数是要读到哪里去， 第三个参数是读取的大小,这一行代码执行完后， cmdcode里面保存的就是要执行的任务码

        if (n == sizeof(cmdcode))
        {
            cout << "slaver get a command : " << getpid() << " : " << "cmdcode" << cmdcode << endl;
            if (cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();
        }
        if (n == 0) break; //如果读到0， 说明写端关闭， 读端读到文件末尾， 就需要停止读取了
        
        cout << "Process PID: " << getpid() << "quit" << endl;
    }
}


//创建管道函数
void InitProcess(vector<channel>* channels)
{
    vector<int> oldfds; //创建一个数组， 用来保存父进程占用的文件描述符
    for (int i = 0; i < processnum; i++)
    {
        //创建管道
        int pipefd[2];
        int n = pipe(pipefd);  //创建一个管道， 并且父进程的读写端都指向这个管道
        if (n != 0) exit(0); //如果创建失败， 直接退出进程
        
        //创建子进程
        pid_t id = fork(); //创建子进程
        if (id == 0)       //执行子进程模块 
        {
            for (auto fd : oldfds) close(fd);   //遍历整个数组， 将已经占用的文件描述符关闭。
            close(pipefd[1]);    //子进程用来读， 所以要关闭子进程的写端
            //核心代码
            dup2(pipefd[0], 0);  //将0号描述符作为读端描述符，（其实这里不用dup2也可以， 博主也不知道这段代码段作用） 但是这么设计是为了更规范，这是一种设计方式
            Slaver(); //核心代码

            exit(0);   
        }
        close(pipefd[0]);
        string name = "process-" + to_string(i);
        channels->push_back(channel(pipefd[1], id, name));  

        oldfds.push_back(pipefd[1]); //记录当前父进程的pipefd[1]里面的占用的文件描述符
    }
}

//创建菜单
void menu()
{
    cout << "*****************************************" << endl;
    cout << "******  1.更新日志      2.更新野区   ******" << endl;
    cout << "******  3.检测更新      4.释放技能   ******" << endl;
    cout << "******  0.退出                      ******" << endl;
    cout << "*****************************************" << endl;
}

//控制子进程
void CtrlSlaver(vector<channel>& channels)
{
    int which = 0;
    int select = 0;

    while(true)
    {
        //1.选择任务， 选择进程
        menu();

        //输入选择，选择执行的任务
        cin >> select;
        if (select <= 0 ||  select >= tasks.size()) break;  //判断select是否合法, 不合法就退出
        int cmdcode = select;
        //
        //2.选择进程
        int processpos = which;  //选择进程使用轮询法， 就是使用which;
        
        cout << "father say cmdcode : " << cmdcode 
            << " already sendto " << channels[which]._cmdfd 
                << " processname : " << channels[which]._processname << endl;   //测试代码打印

        write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode)); //第一个参数为fd输入性参数， 第二个参数为cmdcode要写入的首地址， 
        which++;
        which %= channels.size();

        sleep(1);
    }
}


//清理收尾

void QuitProcess(const vector<channel> &channels)
{
    for (const auto e : channels) 
    {
        close(e._cmdfd);  //写端
        waitpid(e._slarverid, nullptr, 0);
    }
}

int main()
{
    LoadTask(&tasks); //程序打开时就将tasks准备好
    

    //再组织的过程
    vector<channel> channels;


    //创建管道
    InitProcess(&channels);

    //控制子进程
    CtrlSlaver(channels);

    //清理收尾
    QuitProcess(channels);


    return 0;
}

——————以上就是本节全部内容哦， 如果对友友们有帮助的话可以关注博主， 方便学习更多知识哦！！！