Linux - 进程间通信(中)- 管道的应用场景

前言

在上篇博客当中,对Linux 当中的进程通信,做了详细阐述,主要是针对父子进程的通信来阐述的同时,也进行了模拟实现。

对于管道也有了初步了解,但是这仅仅是 进程间通信的一部分,Linux 当中关于进程间通信还有很多的内容,这篇博客将会在上篇博客的基础之上,继续阐述进程间通信。

如有疑问,请看上篇博客:
Linux - 进程间通信(上) - Linux 当中的管道-CSDN博客

管道的应用场景

我们知道,在Linux 当中,有一个命令 -- "|" ,我们也把这个命令称之为管道,那么这个命令和我们上篇博客当中,对于管道的介绍有什么关系呢?

cat text.txt | head -10 | tail-5

比如上述命令,在之前来解释的话,就是把 cat text.txt 的运行结果,通过管道,传输给 head -10 ,然后 head -10 也有有一个输出结果,又把这个输出结果,通过管道,传输给 tail -5,此时得出的结果才是上述命令的最终结果。

 而上述我们所使用的 -- "|" 命令,和 Linux 当中的 pipe 管道是有关系的

 我们拿下述 sleep 这个命令来说明上述 -- "|" 的实现:
 

sleep 6666 | sleep 7777 | sleep 8888

在执行上述命令之前,我们先用 ps 命令查看一下当中 关于 sleep 的进程,发现此时只有一个 sleep 进程: 

当我们执行上述命令之后,发现系统的当中就多出了上述的  sleep 6666 ,sleep 7777 ,sleep 8888 这个三个进程:
 

Linux - 进程间通信(中)- 管道的应用场景_第1张图片

 而这  sleep 6666 ,sleep 7777 ,sleep 8888 这三个进程 的 PPID 都是 18595,也就是说,这三个进程的 PPID (父进程的PID)是一样的。

说明,这三个进程 互相直接的关系是兄弟进程。也就是具有血缘关系。

 很显然,这个18595的PID 是 BASH 的PID。

 而上述的实现也就和上篇博客当中的父子通信的原理是一样的:

首先,操作系统会先创建上述的两个管道,创建之后,在创建   sleep 6666 ,sleep 7777 ,sleep 8888 这三个进程,三个进程通过程序替换的方式,执行不同的代码块。

然后,利用上篇博客当中的对于 进程之间通信的共享文件,哪一个进程是读端,哪一个进程是写端,确定好。

也就是对每一个进程的 0,1,2 号文件,所输入或者输出重定向,使得这些文件的输出和输入不再是单纯的从 键盘文件读取数据,显示器文件输出数据。而是在指定的共享文件当中进行的数据的输入和输出,实现三个进程之间的通信。

这样就建立好了这三个进程之间的链接。

所以,这个 "|" 管道,在底层实现上就是使用 PIPE()函数,实现的 进程之间的通信

 而这 "|" 管道,就是一种匿名管道

 shell 当中实现 "|" 管道 原理

 Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)- 下篇-CSDN博客

Linux - 实现一个简单的 shell-CSDN博客

 上述 Linux - 基础IO(重定向 - 重定向模拟实现 - shell 当中的 重定向)博客当中是对shell 加入 重定向之后的shell,其中大体流程如下所示:

Linux - 进程间通信(中)- 管道的应用场景_第2张图片

显示做出与用户交互的函数,也就是打印出控制台,接受用户输入的命令,判断输入的命令是否有误等等。

然后是对接受到的命令做字符串的分割,把需要执行什么命令解析出来,也就是解析用户的输入的字符串。

然后,判断解析出来的命令,是不是内建命令,如果是,就执行内建命令;如不是,就执行普通命令。

但是,现在要想实现管道的话,管道左右两边的命令可以是内建命令,也可以是普通命令。

所以,我们在解析命令的过程当中,先要解析用户当中有没有 "|" 管道,如果有,就要以 "|" 管道为分割符,把命令一个一个的解析出来;也就是判断,命令字符串当中有多少 "|" ,从而把这个字符串打散为多个字符串。

这些字符串就是一个一个需要执行的命令,所以,需要 malloc 开辟空间来保存这个字符串(如果当中malloc 满了,好临时扩容空间)。

然后,在创建这些命令的子进程之前,需要先创建出 "|",也就是在代码当中写一个循环,在创建管道左右的子进程之时,就可以通过 pipe()函数,链接出左右两个进程之间的 共享文件的链接关系(重定向)。

之后就是循环创建出子进程,对各个子进程的 输入和输出重定向做修改,实现子进程之间的通信。(在管道的最开始就是 1->指定一个管道的写端;管道中间的进程,0标准输入重定向到上一个管道的读端,标准输出指定到下一个管道的写端;最后一个,将标准输入重定向到最后一个管道的读端) 

在让不同的子进程执行不同的命令,也就是 exec* 程序替换,程序替换不会影响到这个进程在替换之间,曾经打开的文件,也就不会影响到曾经预先设置好的重定向文件位置了

通过管道简单实现进程池 

 在 C/C++ 当中有内存池,这样可以更高效的像操作系统申请内存空间供用户使用。其实本质上也就是 像是打水一样,如果每天都需要去河边打一桶水,那么来回的路程,是相对于每一天都需要去跑的,如果,我们一天一次性打上很多桶水。比如是开车 去打上一车的水,这一车的水可以供我们一个星期来使用,那么这个一个星期都可以不同再去河边去打水了。省去了来回在路上往返的消耗了。

同样的,如果要想要操作系统为我们申请内存空间的话,是有消耗的。因为操作系统本身也是有很多事情要去做的,那么在操作系统做完当前事情之前,我们需要去等待。

而且,操作系统也是通过调用底层系统调用接口来实现的,内存属于硬件,硬件就有自己的驱动程序,操作系统在上层,只能一层一层往下去访问到内存硬件资源。这些其实都是有消耗的。

所以,在不浪费内存资源,适量的情况下,预先加载多个内存资源,就可以在一定程度上缓解,通过操作系统申请内存资源所带来的消耗。

同样的,对于申请进程而言,如果单纯的,需要一个进程就去创建一个进程的话,也是和上述一天打一桶水的结果是一样的。都是有消耗的。

创建进程需要申请内存空间,需要有进程地址空间,有进程PCB,由页表等等的内核数据结构,而且,里链接这些内核数据结构也是需要时间的。

所以,在操作系统当中,同样是有 内存池 这样的 “池”的。

我们对这种池的创建,称之为-- 池化技术

我们预先创建好 多个 进程所需的进程资源,当我们想要用到某一个进程资源之时,只需要直接指派这个进程,帮我们去完成任务。


在父进程接受到任务之前,先预先在创建出多个 子进程的资源:
 

Linux - 进程间通信(中)- 管道的应用场景_第3张图片

父进程和每一个子进程之间都建立一条管道的信道, 每一个子进程只负责从管道当中读取数据;而父进程之负责,把对应数据,输入到 对应子进程的管道当中。

如果,父进程没有向一个管道当中写入任何数据,那么这个管道对应的子进程就是阻塞在这个管道当中。等待父进程向管道当中输入数据。

一旦父进程向某一个管道当中写入数据了,那么对应子进程就会读到这些数据,就可以继续执行子进程当中的代码。

我们把父进程向管道当中写入的数据,叫做一个一个的任务码

规定,父进程在写入数据之时,一次只能写 4字节的内容,子进程在读取数据之时,一次也只能读取4字节的内容。总之就是以等长的数据长度写入,以等长的数据长度读取(4字节只是假设,具体要看对应的操作系统的设计)


完整代码

// Task.cpp 
// 任务列表,text.cc 源程序当中,用户从这个 LoadTask ()函数当中选择对应的任务
#pragma once

#include 
#include 

typedef void (*task_t)();

// 下述的 tesk1-4 都是对应的任务
// LoadTask()函数是选择这些任务的函数,供text.cc 源程序当中进行选择
// <---- 这里我们使用函数指针的方式来 使得 子进程能直接跳转到 下述的 tesk1-4 都是对应的任务 函数当中进行执行 ---->
void task1()
{
    std::cout << "lol 刷新日志" << std::endl;
}
void task2()
{
    std::cout << "lol 更新野区,刷新出来野怪" << std::endl;
}
void task3()
{
    std::cout << "lol 检测软件是否更新,如果需要,就提示用户" << std::endl;
}
void task4()
{
    std::cout << "lol 用户释放技能,更新用的血量和蓝量" << std::endl;
}

// 传入一个 vector ,这个容器当中哦弄个存储的是一个一个的任务
// 下述当中的 tasks 是一个输出型参数
void LoadTask(std::vector *tasks)
{
    tasks->push_back(task1);
    tasks->push_back(task2);
    tasks->push_back(task3);
    tasks->push_back(task4);
}


#include "Task.hpp"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

const int processnum = 10;
std::vector tasks;  // 任务列表,用于 LoadTask ()函数返回 任务清单    
                            // 这个 tasks 容器当中存储的是 一个一个 task()任务执行函数的 函数指针
                            // 子进程通过这个函数指针,就可以直接调用到 对应的函数体当中去执行代码
// 先描述
// 父进程为了能管理各个管道
// 把各个管道用结构体对象描述起来
// 一个channel 就是一个管道结构体
class channel
{
public:
    // 用于构造一个 管道类 的构造函数
    channel(int cmdfd, int slaverid, const std::string &processname)
    :_cmdfd(cmdfd), _slaverid(slaverid), _processname(processname)
    {}
public:
    int _cmdfd;               // 发送任务的文件描述符
    pid_t _slaverid;          // 子进程的PID
    std::string _processname; // 子进程的名字 -- 方便我们打印日志
    // int _cmdcnt;
};

// 子进程需要做的事情
void slaver()
{
    // read(0)
    while(true) // 循环一直做,直到做完
    {
        int cmdcode = 0;

        // read参数: (从0号文件当中读取数据, 保存到cmdcode变量当中, 一次只读取 4 字节的内容
        int n = read(0, &cmdcode, sizeof(int)); // 如果父进程不给子进程发送数据呢??阻塞等待!
        if(n == sizeof(int))  // n 是read()的返回值,返回的是 成功从文件当中读取的字节个数
        {
            //执行cmdcode对应的任务列表
            // 先 打印子进程的PID,然后打印 当前从文件当中读取的内容
            std::cout <<"slaver say@ get a command: "<< getpid() << " : cmdcode: " <<  cmdcode << std::endl;

            // 判断当前的 执行任务是否 是在安全区间当中的
            if(cmdcode >= 0 && cmdcode < tasks.size())
                tasks[cmdcode]();  // 执行任务
        }

        // 如果 read() 函数返回返回 0 ,说明读取错误,我们就跳出这个循环
        if(n == 0) break;
    }
}

// 先预先建立好管道共享文件,然后预先创建子进程,把各个子进程和父进程之间连接上管道
void InitProcessPool(std::vector *channels)
{
    // version 2: 确保每一个子进程都只有一个写端
    std::vector oldfds;
    for(int i = 0; i < processnum; i++)
    {
        // pipedf[] 数组用于pipe函数当中的 输出型参数的返回值的存储
        // pipedf[0] 是共享文件的读端;pipedf[1] 是共享文件的写端
        int pipefd[2]; // 临时空间
        int n = pipe(pipefd); // 创建管道
        assert(!n);  // pipe() 创建成功返回0,否则返回 -1
        (void)n;

        pid_t id = fork();   // 创建子进程
        if(id == 0) // child 执行的代码块
        {
            std::cout << "child: " << getpid() << " close history fd: ";
            for(auto fd : oldfds) {
                std::cout << fd << " ";
                close(fd);
            }
            std::cout << "\n";

            close(pipefd[1]); // 关闭写端文件

            // 下述的 进程替换,就是把 子进程当中的 0 号文件,本来是标准输入文件,也就是键盘文件读取数据
            // 现在修改为管道文件的 来读取数据
            // 这样的好处是 以后 子进程就会不用再去管其他的 去哪里接收父进程传输的数据了
            // 只需要“无脑”的从 子进程的 0号文件当中读取数据既可以
            dup2(pipefd[0], 0);  // 进程替换 

            close(pipefd[0]); // 因为上述已经进行了 重定向,所以 pipefd[0] 号文件就可以关闭了
            slaver();         // 执行 子进程当中需要做的任务
            std::cout << "process : " << getpid() << " quit" << std::endl; // 提示子场景完成任务,即将退出
            // slaver(pipefd[0]);
            exit(0); // 子进程退出 , 所以下述代码就可以不同执行了
        }

        // father 执行的代码块
        close(pipefd[0]); // 关闭读端文件

        // 添加channel字段了
        // 往 存储 channel 对象的 vector 容器当中添加当前管道的 channel 对象
        std::string name = "process-" + std::to_string(i);
        channels->push_back(channel(pipefd[1], id, name));
        oldfds.push_back(pipefd[1]);

        sleep(1);
    }
}

void Debug(const std::vector &channels)
{
    // test
    for(const auto &c :channels)
    {
        std::cout << c._cmdfd << " " << c._slaverid << " " << c._processname << std::endl;
    }
}

void Menu()
{
    std::cout << "################################################" << std::endl;
    std::cout << "# 1. 刷新日志             2. 刷新出来野怪        #" << std::endl;
    std::cout << "# 3. 检测软件是否更新      4. 更新用的血量和蓝量  #" << std::endl;
    std::cout << "#                         0. 退出               #" << std::endl;
    std::cout << "#################################################" << std::endl;
}

void ctrlSlaver(const std::vector &channels)
{
    int which = 0;
    // int cnt = 5;
    while(true)
    {
        int select = 0;
        Menu(); // 打印菜单,供用户选择操作
        std::cout << "Please Enter@ ";
        std::cin >> select;


        // 判断用户输入是否正确
        if(select <= 0 || select >= 5) break;
        // select > 0&& select < 5
        // 1. 选择任务
        // int cmdcode = rand()%tasks.size();    // tasks 是定义的全局 vector 容器
        int cmdcode = select - 1;  // 由用户去选择

        // 2. 选择进程
        // 使用随机数来 选择 父进程当前要选择的子进程 来执行子任务
        // 防止 父进程 一直选择 某一个进程来执行任务,那么其他的资源就浪费了
        // 除了这种方式,还可以使用 轮询的方式,也就是递增或者是递减循环选择 子进程的方式来实现
        // write(channels[processpos]._cmdfd, &cmdcode, sizeof(cmdcode)); 这样使用即可
        // int processpos = rand()%channels.size();   这种方式是使用随机数的方式来 进行 选择进程

        std::cout << "father say: " << " cmdcode: " <<
            cmdcode << " already sendto " << channels[which]._slaverid << " process name: " 
                << channels[which]._processname << std::endl;
        // 3. 发送任务
        // 这种使用 which 的方式其实就是一种 轮询的方式 来选择 进程的
        write(channels[which]._cmdfd, &cmdcode, sizeof(cmdcode));

        which++;
        which %= channels.size();  // 不哟让 which 越界了 

        // cnt--;
        // sleep(1);
    }
}
    
// 让所有的进程全部退出
void QuitProcess(const std::vector &channels)
{
    for(const auto &c : channels){
        close(c._cmdfd);  // 将子进程当中的写端直接关闭,这样的话,在子进程当中的 read()函数就会返回 0 
                          // 只要检测到 read()函数返回0 ,就可以在 父进程 控制子进程的函数当中退出 子进程
        waitpid(c._slaverid, nullptr, 0); // 因为此时 QuitProcess ()函数是 父进程执行的
                                          // 子进程退出,父进程要等待子进程退出
    }
    // version1 
    // int last = channels.size()-1;
    // for(int i = last; i >= 0; i--)
    // {
    //     close(channels[i]._cmdfd);
    //     waitpid(channels[i]._slaverid, nullptr, 0);
    // }

    // for(const auto &c : channels) close(c._cmdfd);
    // // sleep(5);
    // for(const auto &c : channels) waitpid(c._slaverid, nullptr, 0);
    // // sleep(5);
}
int main()
{
    LoadTask(&tasks);  // 获取到任务 tasks 是定义的全局 vector 容器

    srand(time(nullptr)^getpid()^1023); // 种一个随机数种子

    // 在组织
    // 用下述的 vector  数据结构把 一个一个的管道结构体管理起来
    // 从此之后,父进程管理一个一个的管道,就变成了对这个 vector 数据结构的增删查改
    std::vector channels;

    // 1. 初始化 --- bug?? -- 找一下这个问题在哪里?然后提出一些解决方案!
    InitProcessPool(&channels);
    // Debug(channels);

    // 2. 开始控制子进程
    ctrlSlaver(channels);

    // 3. 清理收尾
    QuitProcess(channels);
    return 0;
}

你可能感兴趣的:(linux,运维,服务器)