【Linux】进程间通信 -- 匿名管道的应用

前言

上篇博客初步学习了匿名管道的周边知识和使用，本篇文章将基于这些知识，实现一下进程间通信
话不多说，马上开始今天的内容

一. 大体框架

我们创建一个进程，以这个进程为父进程，创建5个子进程和对应的管道，父进程进行写操作，子进程进行读操作，根据父进程写入的数据，进行相应的动作。

部分细节，变量在单独部分没有展示，可以查看完整代码部分

二. 分配任务

这个部分我们可以编写在Task.hpp

#pragma once

#include<iostream>
#include<vector>
#include<unistd.h>

//函数指针
typedef void(*fun_t)();

void PrintLog()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 打印日志任务，正在被执行"<<std::endl;
}

void InsertMySQL()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 执行数据库任务，正在被执行"<<std::endl;
}

void NetRequest()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 执行网络请求任务，正在被执行"<<std::endl;
}

//数字对应的指令
#define COMMAND_LOG 1
#define COMMAND_MYSQL 2
#define COMMAND_REQUEST 3

class Task
{
    
    
public:
    Task()
    {
    
    
        funcs.push_back(PrintLog);
        funcs.push_back(InsertMySQL);
        funcs.push_back(NetRequest);
    }

    void Execute(int command)
    {
    
    
        //commend是执行第几个命令
        if(command>=0&&command<funcs.size())
        {
    
    
            funcs[command]();
        }
    }

    ~Task()
    {
    
    

    }
public:
    std::vector<fun_t>funcs;
};

我们使用函数指针的方式。定义一个Task类，内部有一个存储函数指针的vector，并且我们在其构造函数中，就添加以上三个任务。然后还有一个接口，通过传入一个数字command，然后执行对应vector里第几个的任务。

三. 创建控制模块

从这部分开始，我们编写在ctrlProcess.cpp中

匿名管道用于具有“亲戚关系”的进程，常用的就是父子进程，而我们需要让子进程有父进程创建的管道，所以需要先创建管道，然后再创建子进程，这样因为写时拷贝，子进程就会继承父进程的部分进程信息，当然包括文件描述符。
然后成功创建一个子进程后，父进程要先关闭当前管道的读端，这样不会影响下一次的创建。
同时，因为我们要创建多个子进程，而每次创建的管道，都使用同一个数组，存储其读写文件描述符，所以我们使用一个类，内部存储子进程的名称，子进程的pid，子进程对应的管道的写端，因为父进程需要向该写端写入数据。这样也符合，先描述，再组织的思想。

我们将这部分封装成一个函数，将每一步操作封装起来，这样也可以让代码更有逻辑性，可读性更好。

子进程的waitCommand函数将在下一部分讲解，因为waitCommand是读取管道数据，属于通信部分。

// 用于存储子进程的pid和相对应管道的文件描述符
class EndPoint
{
    
    
    //计数器
    static int number;
public:
    EndPoint(pid_t child_id, int write_id)
        : _child_id(child_id), _write_id(write_id)
    {
    
    
        //进程名的格式：process-0[pid,fd]
        char namebuffer[64];
        snprintf(namebuffer,sizeof(namebuffer),"process-%d[%d:%d]",number++,_child_id,_write_id);
        processname=namebuffer;
    }

    std::string name() const
    {
    
    
        return processname;
    }

    ~EndPoint()
    {
    
    
    }

public:
    pid_t _child_id; // 子进程的pid
    int _write_id;   // 相对应管道的文件描述符
    std::string processname; //进程的名字 
};
int EndPoint::number=0;


// 构建控制结构，父进程写入，子进程读取
void createProcesses(vector<EndPoint> &end_points)
{
    
    
    // 1.先进行构建控制结构：父进程进行写入，子进程读取
    for (int i = 0; i < gnum; i++)
    {
    
    
        // 1.1 创建管道
        int pipefd[2] = {
    
    0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void )n; // 防止release版本将为使用的变量删除

        // 1.2 创建子进程
        pid_t id = fork();
        assert(id != -1);
        (void )id; // 防止release版本将为使用的变量删除

        if (id == 0)
        {
    
    
            // 子进程

            //将从父进程那继承来的其他进程的读端关闭
            cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端：";
            for(const auto&ep:end_points)
            {
    
    
                cout<<ep._write_id<<" ";
                close(ep._write_id);
            }
            cout<<endl;

            // 关闭自己的写端
            close(pipefd[1]);

            // 1.3 通信

            // 子进程读取“指令”，都从标准输出中获取
            // 将管道的读重定向到标准输出中
            dup2(pipefd[0], 0);

            // 1.4 子进程开始等待命令。
            WaitCommand();

            // 关闭读端然后退出子进程
            close(pipefd[0]);
            exit(0);
        }

        // 到这的一定是父进程

        // 关闭读端
        close(pipefd[0]);

        // 将新创建的子进程的fd和管道的写的文件描述符存储起来
        end_points.push_back(EndPoint(id, pipefd[1]));
    }
}

但这里，我们还需要注意一个事项，就是子进程创建成功后，还有一个循环

//将从父进程那继承来的其他进程的读端关闭
cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端"<<endl;
for(const auto&ep:end_points)
{
    
    
	cout<<ep._write_id<<" ";
    close(ep._write_id);
}
cout<<endl;

这一步我们在最后的退出程序再详细讲解。

四. 开始通信

我们现在已经创建好父子进程，并且还存储好了子进程的pid和对应管道的写端的文件描述符。
接下来，我们就可以开始通信了。

父进程往管道写入

//展示面板
int ShowBoard()
{
    
    
    cout<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"# 0. 执行日志任务   1. 执行数据库任务 #"<<endl;
    cout<<"# 2. 执行请求任务   3. 退出           #"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"请选择# ";

    int command=0;
    std::cin>>command;

    return command;
}

//父进程写入
void ctrlProcess(const vector<EndPoint>&end_points)
{
    
    
    // 父进程开始发布命令
    int cnt=0;
    while(true)
    {
    
    
        //1. 选择任务
        int command=ShowBoard();
        //为3就退出
        if(command==3)
        {
    
    
            break;
        }

        if(command<0&&command>2)
        {
    
    
            cout<<"输入有误，请重新输入"<<endl;
            continue;
        }

        //2. 按顺序给子进程派发任务
        int indix=cnt++;
        cnt%=end_points.size();

        cout<<"你选择了进程："<<end_points[indix].name()<<" | 处理"<<command<<"号任务"<<endl;

        //4. 下发任务
        write(end_points[indix]._write_id,&command,sizeof(command));
        
        sleep(1);
    }
}

子进程读取管道，获取数据，并执行相应任务

// 子进程读数据
void WaitCommand()
{
    
    
    while(true)
    {
    
    
        int command;
        //一次读取4个字节
        int n = read(0, &command, sizeof(int));
        //成功读取4字节，就执行对应的命令
        if (n == sizeof(int))
        {
    
    
            t.Execute(command);
            cout<<endl;
        }
        else if (n == 0)
        {
    
    
            //相对应的写端关闭了
            cout<<"父进程让我退出，我就退出了"<<getpid()<<endl;
            break;
        }
    }
}

五. 关闭程序

在关闭程序时，我们要结束子进程，只需要将对应的写端关闭，子进程读取到文件尾，就会自动退出循环，结束进程。
然后父进程还需要回收子进程的僵尸状态。
不过这里我们要讲解第二步. 分配任务时的一个疑问

为什么需要下面这个循环

//将从父进程那继承来的其他进程的读端关闭
cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端"<<endl;
for(const auto&ep:end_points)
{
    
    
	cout<<ep._write_id<<" ";
    close(ep._write_id);
}
cout<<endl;

我们知道，子进程会继承父进程所有的文件描述符，那么当我们创建第二个子进程前，父进程是有第一个子进程管道的写端的。所以第二个子进程同样会继承这个文件描述符，这样就导致，我们创建越多的子进程，前面的子进程的管道的链接数越多，引用计数不为1，这样顺序一个一个关闭时，无法关闭子进程的写端，子进程就不会读到文件尾，而是处于阻塞状态，不会退出进程，父进程就回收不到子进程了。
所以我们有三种解决这个问题的办法

解决方法一：
我们可以一次性将所有子进程的写端都关闭，再回收子进程

	//1.关闭子进程的写端
    for(const auto&ep:end_points)
    {
    
    
        close(ep._write_id);
    }

    sleep(5);
    cout<<"父进程让所有的子进程都退出"<<endl;
    
    //2. 父进程回收子进程的僵尸状态
    for(const auto&ep:end_points)
    {
    
    
        waitpid(ep._child_id,nullptr,0);
    }

    cout<<"父进程回收了所有的子进程"<<endl;
    sleep(5);

解决方法二：
我们可以倒着关闭子进程的写端，然后再回收子进程

	//倒着关闭子进程的写端，再回收子进程
    for(int i=end_points.size()-1;i>=0;i--)
    {
    
    
        close(end_points[i]._write_id);
        cout<<"父进程让"<<end_points[i]._child_id<<"子进程退出"<<endl;

        waitpid(end_points[i]._child_id,nullptr,0);
        cout<<"父进程回收了"<<end_points[i]._child_id<<"子进程"<<endl;
        cout<<endl;

        sleep(1);
    }

解决方法三：
在新的子进程创建后，关闭从父进程那继承的其他子进程的管道的文件描述符，就是那个循环，
然后我们就可以顺序的，一个一个关闭写端并回收了

//将从父进程那继承来的其他进程的读端关闭
cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端"<<endl;
for(const auto&ep:end_points)
{
    
    
	cout<<ep._write_id<<" ";
    close(ep._write_id);
}
cout<<endl;

//一个一个退出
for(const auto&ep:end_points)
{
    
    
	close(ep._write_id);
    cout<<"父进程让"<<ep._child_id<<"子进程退出"<<endl;

    waitpid(ep._child_id,nullptr,0);
    cout<<"父进程回收了"<<ep._child_id<<"子进程"<<endl;
    cout<<endl;

    sleep(1);
}

六. 完整代码

Task.hpp

#pragma once

#include<iostream>
#include<vector>
#include<unistd.h>

//函数指针
typedef void(*fun_t)();

void PrintLog()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 打印日志任务，正在被执行"<<std::endl;
}

void InsertMySQL()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 执行数据库任务，正在被执行"<<std::endl;
}

void NetRequest()
{
    
    
    std::cout<<"pid:"<<getpid()<<" 执行网络请求任务，正在被执行"<<std::endl;
}

//数字对应的指令
#define COMMAND_LOG 1
#define COMMAND_MYSQL 2
#define COMMAND_REQUEST 3

class Task
{
    
    
public:
    Task()
    {
    
    
        funcs.push_back(PrintLog);
        funcs.push_back(InsertMySQL);
        funcs.push_back(NetRequest);
    }

    void Execute(int command)
    {
    
    
        //commend是执行第几个命令
        if(command>=0&&command<funcs.size())
        {
    
    
            funcs[command]();
        }
    }

    ~Task()
    {
    
    

    }
public:
    std::vector<fun_t>funcs;
};

ctrlProcess.cpp

#include <iostream>
#include <string>
#include <cassert>
#include <unistd.h>
#include <vector>
#include <sys/types.h>
#include <sys/wait.h>
#include "task.hpp"

using namespace std;

const int gnum = 3;
Task t; // 定义为全局的

// 用于存储子进程的pid和相对应管道的文件描述符
class EndPoint
{
    
    
    //计数器
    static int number;
public:
    EndPoint(pid_t child_id, int write_id)
        : _child_id(child_id), _write_id(write_id)
    {
    
    
        //进程名的格式：process-0[pid,fd]
        char namebuffer[64];
        snprintf(namebuffer,sizeof(namebuffer),"process-%d[%d:%d]",number++,_child_id,_write_id);
        processname=namebuffer;
    }

    std::string name() const
    {
    
    
        return processname;
    }

    ~EndPoint()
    {
    
    
    }

public:
    pid_t _child_id; // 子进程的pid
    int _write_id;   // 相对应管道的文件描述符
    std::string processname; //进程的名字 
};
int EndPoint::number=0;

// 子进程读数据
void WaitCommand()
{
    
    
    while(true)
    {
    
    
        int command;
        //一次读取4个字节
        int n = read(0, &command, sizeof(int));
        //成功读取4字节，就执行对应的命令
        if (n == sizeof(int))
        {
    
    
            t.Execute(command);
            cout<<endl;
        }
        else if (n == 0)
        {
    
    
            //相对应的写端关闭了
            cout<<"父进程让我退出，我就退出了"<<getpid()<<endl;
            break;
        }
    }
}

// 构建控制结构，父进程写入，子进程读取
void createProcesses(vector<EndPoint> &end_points)
{
    
    
    // 1.先进行构建控制结构：父进程进行写入，子进程读取
    for (int i = 0; i < gnum; i++)
    {
    
    
        // 1.1 创建管道
        int pipefd[2] = {
    
    0};
        int n = pipe(pipefd);
        assert(n == 0);
        (void )n; // 防止release版本将为使用的变量删除

        // 1.2 创建子进程
        pid_t id = fork();
        assert(id != -1);
        (void )id; // 防止release版本将为使用的变量删除

        if (id == 0)
        {
    
    
            // 子进程

            //将从父进程那继承来的其他进程的读端关闭
            cout<<getpid()<<" 子进程关闭了继承自父进程的其他子进程的写端：";
            for(const auto&ep:end_points)
            {
    
    
                cout<<ep._write_id<<" ";
                close(ep._write_id);
            }
            cout<<endl;

            // 关闭自己的写端
            close(pipefd[1]);

            // 1.3 通信

            // 子进程读取“指令”，都从标准输出中获取
            // 将管道的读重定向到标准输出中
            dup2(pipefd[0], 0);

            // 1.4 子进程开始等待命令。
            WaitCommand();

            // 关闭读端然后退出子进程
            close(pipefd[0]);
            exit(0);
        }

        // 到这的一定是父进程

        // 关闭读端
        close(pipefd[0]);

        // 将新创建的子进程的fd和管道的写的文件描述符存储起来
        end_points.push_back(EndPoint(id, pipefd[1]));
    }
}

int ShowBoard()
{
    
    
    cout<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"# 0. 执行日志任务   1. 执行数据库任务 #"<<endl;
    cout<<"# 2. 执行请求任务   3. 退出           #"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"#######################################"<<endl;
    cout<<"请选择# ";

    int command=0;
    std::cin>>command;

    return command;
}

void ctrlProcess(const vector<EndPoint>&end_points)
{
    
    
    // 父进程开始发布命令
    int cnt=0;
    while(true)
    {
    
    
        //1. 选择任务
        int command=ShowBoard();
        //为3就退出
        if(command==3)
        {
    
    
            break;
        }

        if(command<0&&command>2)
        {
    
    
            cout<<"输入有误，请重新输入"<<endl;
            continue;
        }

        //2. 按顺序给子进程派发任务
        int indix=cnt++;
        cnt%=end_points.size();

        cout<<"你选择了进程："<<end_points[indix].name()<<" | 处理"<<command<<"号任务"<<endl;

        //4. 下发任务
        write(end_points[indix]._write_id,&command,sizeof(command));
        
        sleep(1);
    }
}

//回收子进程
void waitProcess(vector<EndPoint>&end_points)
{
    
    
    //如果我们创建管道后，直接再创建子进程，那么子进程将继承父进程的所有文件描述符，
    //后创建的子进程会保留指向先创建的管道的读写文件描述符
    //所以顺序同时关闭子进程的写端和回收僵尸进程，其实并没有关闭子进程的写端，因为此时其引用计数仍>0

    // //这种写法会在waitpid时堵塞，因为子进程的写端还没有关闭
    // //所以子进程的读端处于堵塞状态，不会退出
    // for(const auto&ep:end_points)
    // {
    
    
    //     close(ep._write_id);
    //     cout<<"父进程关闭了"<<ep._child_id<<"的写端"<<endl;
    //     waitpid(ep._child_id,nullptr,0);
    //     cout<<"父进程回收了"<<ep._child_id<<endl;
    // }

    //解决方法一：倒着关闭写端，回收僵尸进程
    //解决方法二：在创建新的子进程后，子进程关闭从父进程那边继承的其他子进程的读写端


    //我们只需要让父进程关闭子进程的写端，子进程的读端会读到文件尾，然后自己就退了。

    // //1.关闭子进程的写端
    // for(const auto&ep:end_points)
    // {
    
    
    //     close(ep._write_id);
    // }

    // sleep(5);
    // cout<<"父进程让所有的子进程都退出"<<endl;
    
    // //2. 父进程回收子进程的僵尸状态
    // for(const auto&ep:end_points)
    // {
    
    
    //     waitpid(ep._child_id,nullptr,0);
    // }

    // cout<<"父进程回收了所有的子进程"<<endl;
    // sleep(5);

    //倒着关闭子进程的写端，再回收子进程
    for(int i=end_points.size()-1;i>=0;i--)
    {
    
    
        close(end_points[i]._write_id);
        cout<<"父进程让"<<end_points[i]._child_id<<"子进程退出"<<endl;

        waitpid(end_points[i]._child_id,nullptr,0);
        cout<<"父进程回收了"<<end_points[i]._child_id<<"子进程"<<endl;
        cout<<endl;

        sleep(1);
    }



    //一个一个退出
    for(const auto&ep:end_points)
    {
    
    
        close(ep._write_id);
        cout<<"父进程让"<<ep._child_id<<"子进程退出"<<endl;

        waitpid(ep._child_id,nullptr,0);
        cout<<"父进程回收了"<<ep._child_id<<"子进程"<<endl;
        cout<<endl;

        sleep(1);
    }

}

int main()
{
    
    
    // 用于存储子进程的pid和相对应管道的文件描述符
    vector<EndPoint> end_points;

    // 创建控制模块
    createProcesses(end_points);
    sleep(1);
    //开始通信
    ctrlProcess(end_points);

    //回收子进程
    waitProcess(end_points);

    cout<<"程序成功退出，欢迎下次使用"<<endl;

    return 0;
}

以下为部分运行结果

结束语

本篇文章内容到此结束，感谢你的阅读

如果觉得本篇文章对你有所帮助的话，不妨点个赞支持一下博主，拜托啦，这对我真的很重要。