28 管道

概念

管道式Unix中最古老的进程间通信的形式
把从一个进程连接到另一个进程的一个数据流称为一个“管道”

原理

task_struct中保存了一个files的结构体数组，里面存储了所有打开文件的编号，新打开一个文件，数据会写入到文件对应的 缓冲区中去，生成子进程时，也会有一个files的数组，两个进程访问同一个文件的缓冲区，而不写入到磁盘，内存级别的文件。本质就是让不同的进程，看到同一份资源，管道就是文件。但如果是读权限打开，子进程也只有读权限，所以父进程的打开不是随便打开

想要通信就要同时读和写，所以需要有读写权限，同时为了父子进程的读和写相互不影响，方便区分数据方，设计简单，让这个文件打开两次，一个用来读，一个用来写，创建子进程也会有这两个文件，但操作系统不会做低效率的事，所以同一个文件指向同一个缓冲区。读和写分别在两个位置，互不干扰。父进程和子进程实现单向通信，父进程只读，就关闭写文件，防止误操作，子进程只写，就关闭读文件

如果进行双向通信呢，可以用多个管道

如果没有任何关系，不能用这个原理通信，必须是父子，兄弟，爷孙等等，进程之间要有血缘关系

接口

匿名管道

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码

fd是输出型参数，带出文件描述符让用户使用的

测试

使用pipe函数看看返回值是不是3和4

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

using namespace std;

int main()
{
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    
    //出错
    if (n < 0)
    {
        return 1;
    }

    cout << "pfd[0]:" << pipefd[0] << ",pfd[1]:" << pipefd[1];
}

子进程利用4号管道不断写入内容,父进程读取内容

#include <iostream>
#include <unistd.h>
#include <cstdlib>  //stdlib
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/wait.h>

using namespace std;

//写
void Writer(int wfd)
{
    string str = "hello i am chlid";
    pid_t self = getpid();
    int num = 0;

    char buff[1024];
    while (true)
    {
        buff[0] = 0;  //字符串清空,提醒阅读的人,这个数组当字符串
        num++;
        snprintf(buff, sizeof(buff), "%s-%d-%d", str.c_str(), self, num);
       // cout << buff << endl;
       //发送给父进程
        write(wfd, buff, strlen(buff));  //不用加1,文件不遵守c语言
        sleep(1);
    }
}

//读
void Reader(int rfd)
{
    char buff[1024];
    while (true)
    {
        buff[0] = 0;
        ssize_t n = read(rfd, buff, sizeof(buff));
        if (n > 0)
        {
            buff[n] = 0; //c串格式读
            cout << "父进程读到消息[" << getpid() << "]: " << buff << endl;
        }
    }
}

//子进程写 父进程读
int main()
{
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    
    //出错
    if (n < 0)
    {
        return 1;
    }

   // cout << "pfd[0]:" << pipefd[0] << ",pfd[1]:" << pipefd[1] << endl;

    pid_t id = fork();
    if (id < 0)
    {
        return 2;
    }
    else if (id == 0)
    {
        //子进程写
        //关闭读
        close(pipefd[0]);
        //IPC code
        Writer(pipefd[1]);
        // 操作完关闭写
        close(pipefd[1]);
        exit(0);
    }

    //父进程读,关闭写
    close(pipefd[1]);
    //IPC code
    Reader(pipefd[0]);
    pid_t rid = waitpid(id, nullptr, 0);
    if (rid < 0)
    {
        return 3;
    }
    // 操作完关闭
    close(pipefd[0]);
}

先将数据放入用户级缓冲区，将用户级缓冲区的数据写入文件缓冲区，读端在从文件缓冲区读到用户缓冲区，经历两次拷贝

管道特征

子进程每隔一秒写一次，父进程没有休眠，也是每隔一秒读了一次，如果将子进程休眠时间改为50，父进程也会等待50秒

父进程不能读到无用数据,也避免访问冲突,要和子进程配合访问

父进程先不读取，子进程疯狂写，写满之后，父进程会一次性读取所有内容，也可以分多次读，在读端看来，是一个个字符，并不清楚结构，由用户自己区分，这就是管道面向字节流，如果需要有格式，就要有协议

1.具有血缘关系的进程才能进行进程间通信
2.只能单向通信
3.父子进程会协同，同步与互斥–保护管道文件的数据安全
4.管道面向字节流
5.管道是基于文件的，文件的声明周期是随进程的，进程退出了，管道就会自然释放关掉，如 0,1,2没有关过

四种情况

1.读写端正常，管道如果为空，读端要阻塞
2.读写端正常，管道如果被写满，写端就要阻塞
3.读写端不正常，写端关闭，读端会读到0，表明读到了文件结尾，不会被阻塞
4.写端正常，读端关闭，os就要通过信号杀掉正在写入的进程，13信号SIGPIPE

读取的原则性问题，当hello刚写入，父进程就读去了，但需要读的是完整的hello world，所以就要设置一个大小，不达到这个大小，就算有数据也不读。pipesize就是管道的大小

操作系统不会做低效，浪费等类似的工作，如果做了，就是bug

查看配置

查看各个管道大小

ulimit -a

云服务器的open files本来32,64，一般都会拉满
pipe size，8^*512，就是4kb，可以验证，写端不停写，用一个数字累加，最后显示，有的默认64kb，可以配置

查看centos版本

cat /etc/redhat-release

查看管道大小说明

man 7 pipe

应用

之前shell里打出的命令|就是管道，运行三个sleep程序可以发现都是源于同一个父进程，这个父进程就是bash，这批进程就是血缘关系，创建两个管道，然后创建三个进程，对进程的标准输出标准输入重定向后就可以，就可以勾连这几个进程运行起来

shell添加重定向

字符串分割需要判断是否有管道，获取有多少个管道，malloc申请空间，创建多个管道，循环创建多个子进程，每一个子进程重定向，第一个进程输出重定向到指定管道的写端，中间的进程输入输出重定向，输入重定向到上一个管道的读端，标准输出重定向到下一个管道的写端，最后一个进程输入重定向，标准输入重定向到最后一个管道的读端。让不同的进程执行不同的命令，程序替换不会影响曾经打开的文件，不会影响预先设置好的管道重定向

进程池

需要多次创建进程，需要执行任务的时候在创建。可以改为一次性创建多个进程，当需要执行任务时直接分配，省去和操作系统多次交互的过程

创建多个进程和管道，主进程作为写端，给子进程发送命令，当没有接受到命令时子进程就会阻塞，有命令时就会从管道中获取去执行

思路
一个文件定义出需要执行的任务类型和内容，用来分配

#pragma once
#include <iostream>
#include <vector>

using namespace std;
typedef void (*task)();

void task0()
{
    cout << "0号任务刷新野怪" << std::endl;
}

void task1()
{
    cout << "1号任务刷洗日志" << std::endl;
}

void task2()
{
    cout << "2号任务检测更新" << std::endl;
}

void task3()
{
    cout << "3号任务释放技能" << std::endl;
}

void loadtask(vector<task>* v)
{
    v->push_back(task0);
    v->push_back(task1);
    v->push_back(task2);
    v->push_back(task3);
}

先调用上面的功能加载任务，构建一个结构来管理所有的管道，需要知道管道的编号，子进程的pid，子进程的命名用来打印日志信息。初始化进程池，根据需要创建管道和子进程，然后执行任务，等待主进程发送任务，读到任务调用函数指针。主进程根据菜单选项随机选择一个进程发送任务，往管道里写入内容，退出时关闭写端，进程结束

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

const int processnum = 5;
//加载任务
std::vector<task> tasks;

//先描述
class channel
{
public:
    channel(int fd, pid_t id, std::string& process)
    :_cmdfd(fd), _slaverid(id), _processname(process)
    {}

    int _cmdfd;     //发送任务的文件描述符
    pid_t _slaverid; //子进程pid
    std::string _processname;  //子进程名字,方便打印日志
};

//等待任务
void slaver()
{
    while (true)
    {
        //std::cout << rfd << std::endl;
        //读到int再执行
        int cmdcode;
        ssize_t ret = read(3, &cmdcode, sizeof(int));
        if (ret == sizeof(int))
        {
            std::cout << getpid() << "收到任务: " << cmdcode << std::endl;
            if (cmdcode >= 0 && cmdcode < tasks.size())
            {
                 tasks[cmdcode]();
            }      
        }
        if (ret == 0)
        {
            std::cout << "读到0退出";
            break;
        }
        sleep(1);
    }
}

void initpool(std::vector<channel>* v)
{
    std::vector<int> oldds;
    for (int i = 0; i < processnum; i++)
    {
        int pipefd[2];  //临时空间
        int n = pipe(pipefd);
        assert(!n);
       
        pid_t id = fork();
        if (id < 0)
        {
            return;
        }
        else if (id == 0)
        {
            for(auto ch : oldds)
            {
               // std::cout << "子进程补充关闭 " << ch;
                close(ch);
            }
           // printf("\n");
            // child
            close(pipefd[1]);
            //替换后从标准输入读取
            dup2(pipefd[0], 0);
            oldds.push_back(pipefd[0]);
            slaver();
            std::cout << getpid() << "退出" << std::endl;
            exit(0);
        }

        close(pipefd[0]);

        //父类添加成员
        std::string str = "process: " + std::to_string(i);
        v->push_back(channel(pipefd[1], id, str));
        oldds.push_back(pipefd[1]);

    }
}

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 crtlslaver(const std::vector<channel>& v)
{
    //int which = 0;
    menu();

    while (true)
    {
        int wid = 0;
        std::cin >> wid;
        if (wid <= 0 || wid > 4)
        {
            break;
        }
        // 选择任务,负载均衡,随机或轮询
       // int wid = rand() % tasks.size();
        // 选择进程
        int processpos = rand() % v.size();
        // 发送任务
        write(v[processpos]._cmdfd, &wid, sizeof(int));
        std::cout << "父进程给" << v[processpos]._slaverid << "发送" << wid << "号任务" << std::endl;
        sleep(1);
       // which++;
    }

}

void debug(const std::vector<channel>& v)
{
  for (auto& ch : v)
    {
        std::cout << ch._cmdfd << " " << ch._slaverid << " " << ch._processname << std::endl;
    }
}

void quitprocess(std::vector<channel>& v)
{
    for (auto ch : v)
    {
        close(ch._cmdfd);
        waitpid(ch._slaverid, nullptr, 0);
        // sleep(2);
    }
}

int main()
{
    //随机数种子
    srand(time(nullptr) ^ getpid() ^ 1023);  //位或更离散一点
    //加载任务
    loadtask(&tasks);
    // 再组织
    std::vector<channel> channels;
    //初始化
    //创建管道
    initpool(&channels);

    // 开始控制子进程
    // test
    // debug(v);
    crtlslaver(channels);
    // 清理
    quitprocess(channels);
    sleep(5);

    return 0;
}

效果

上面的生成子进程的过程中，需要保存上一个主进程的写端，因为子进程在继承父进程时，也会继承它的写端，然后又创建了一个写端，会出现重复的写端，保存后每次把不需要的关闭