进程池，记得看注释

我们要模拟的是什么呢？

模拟父进程控制子进程执行任务

 我们该怎么去控制呢，我们控制这些子进程本质是去管理这些子进程，那么就离不开

先描述再组织，也就是我们把每个子进程的内核数据信息交给父进程管理，父进程调用

操作系统的接口去管理子进程。描述的话就是把每个子进程的信息描述起来，管理就是

父进程用操作系统提供的接口去控制子进程执行。

---

我们先把框架搭起来

1.1创建管道

1.2创建子进程

子进程(1.3.0关闭自身写端,1.3.1 输入重定向,1.3.2子进程开始等待获取父进程发送的命令)

父进程(1.3.3关闭父进程的读端,1.4存放子进程信息)

父进程(发命令控制子进程)

父进程(回收子进程)

总结就是三步

1.创建子进程并收集子进程信息

2.控制子进程

3.回收子进程

下面我们跟着代码去探索本质

#include <iostream>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <string>
#include <vector>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <cerrno>
#include "Task.hpp"
#include <stdio.h>
Task T;
const int gnum = 5;
class EndPoint
{
private:
  static int num;
public:
  pid_t _child_id;
  int _write_fd;
  std::string processname;
public:
  EndPoint(int id,int fd):_child_id(id),_write_fd(fd)
  {
    char namebuffer[64];
    snprintf(namebuffer,sizeof(namebuffer),"porcess-%d[%d-%d]",num++,_child_id,_write_fd);
    processname = namebuffer;//运算符重载=
  } 
  ~EndPoint()
  {}
};
int EndPoint::num = 0;
//子进程接受到命令，执行任务
void WaitCommand()
{ 
  while(1)
  {
    int command;
    int n = read(0,&command,sizeof(int));//以字节流读取，我们要的是command，整形，读取也是
  //读 整形的4个字节
    std::cout<<"recv cmd:"<<command<<std::endl;
    if(n == 0)
    {
      std::cerr<<errno<<":"<<strerror(errno)<<std::endl;
      break;
    }
    else if(n == sizeof(int))
    {
      T.Execute(command);
    }
    else
    {
      std::cerr<<errno<<":"<<strerror(errno)<<std::endl;
      break;
    }
  }
}

void createProcesses(std::vector<EndPoint>* end_point)
{
  std::vector<int> fds;
  for(int i = 0;i < gnum;i++)
  { 
    //1.1创建管道
    int pipefd[2] = {0};
    int n = pipe(pipefd);
    assert(n == 0);
    (void)n;
    //1.2创建进程
    pid_t id = fork();
    assert(id != -1);
    

    if(id == 0)
    {
      for(auto &fd:fds) close(fd);
      //这个点很重要，子进程关闭从父进程继承下来的写端
      
      //关闭自身写端
      close(pipefd[1]);

      //我们期望子进程在读取指令的时候 ，从标准输入读取
      //1.3.1 输入重定向
      //dup2
      dup2(pipefd[0],0);
      
      //1.3.2子进程开始等待获取父进程发送的命令
      WaitCommand();
      std::cout<<"子进程等待命令终于结束了，阻塞的好累"<<std::endl;
      //子进程退出，关闭读端
      close(pipefd[0]);
      exit(0); 
    }

    //父进程写入
    close(pipefd[0]);//1.3关闭父进程的读端

    //1.4 
    end_point->push_back(EndPoint(id,pipefd[1]));
    fds.push_back(pipefd[1]);
  }
}

void show_board()
{
   std::cout<<"#################"<<"0:执行日志任务"<<"  ##################"<<std::endl;
   std::cout<<"#################"<<"1:执行数据库任务"<<"##################"<<std::endl;
   std::cout<<"#################"<<"2:执行网络请求任务"<<"################"<<std::endl;
   std::cout<<"#################"<<"3:执行通行任务"<<" ##################"<<std::endl;
   std::cout<<"#################"<<">3:退出"<<" ##################"<<std::endl;
}

//负载均衡算法
void CtrlProcess(const std::vector<EndPoint>& end_point)
{
  //父进程进行写入命令
  int cnt = 0;//我们变成轮询式的
  show_board();
  while(1)
  {
     //1.选择任务
     int command = 0;
     std::cin>>command;
     if(command > 3) break;
     //2.选择进程
     cnt %= end_point.size();

     //3.下发任务
     std::cout<<end_point[cnt].processname<<std::endl; 
     write(end_point[cnt]._write_fd,&command,sizeof(command));
     cnt++;
     sleep(1);//我们写入之后，子进程读到命令，然后执行相应命令的任务，由于我们的执行速度很快，我们的父进程在执行向显示打印的时候
     //子进程也在打印，此时我们父子进程并发式的向子进程打印，那么就会去抢占数据，可能会数据改错，我们让父进程等一等，也就是让父进程执行的
     //操作系统知道不需要
  }

}


void WaitChild(const std::vector<EndPoint>& end_point)
{
   //子进程写端关闭，父进程读端关闭，要想子进程退出，因为子进程的读端
   //是受父进程的写端影响的,所以父进程写端关闭，读端读完自然就会退出该进程
   //还有要回收
    for(const auto &end: end_point) close(end._write_fd);
   
    //回收所有子进程
    int cnt = 0;
    for(const auto &end: end_point) 
    { 
      pid_t ret = waitpid(end._child_id,nullptr,0);
      if(ret > 0) 
      {
        std::cout<<"等待成功,id是:"<<ret<<std::endl;
        cnt++;
      }
    }
  //这段代码其实也有不足，只是碰巧把最后一个给关闭，因为倒着关闭刚好可以把所有写端关闭
  //所以不会堵塞，但是这种做法不合适——取巧，所以采用第二种做法，每次在创建
  //新的子进程的时候，
  // int cnt = 0;
  // for(const auto &end: end_point) 
  // {
  //     close(end._write_fd);

  //     pid_t ret = waitpid(end._child_id,nullptr,0);
  //     if(ret > 0) 
  //     {
  //       std::cout<<"等待成功,id是:"<<ret<<std::endl;
  //       cnt++;
  //     }
  // }
   if(cnt == end_point.size()) std::cout<<"父进程回收了所有子进程"<<std::endl;
   else std::cout<<"内存泄漏"<<std::endl;
}
  
int main()
{
  //1.先进行创建控制结构,父进程写，子进程读
  std::vector<EndPoint> end_point;
  createProcesses(&end_point);//子进程阻塞在那等待读命令，等待读命令的时候，这个函数的代码被父进程执行把进程id写入到EndPoint对象中
  //然后此时该子进程是堵塞在那等待命令，父进程进行执行循环体，以下同理
  //同理循环完后，其实是有五个子进程在那从管道中读，因为管道里没有数据，所以堵塞在那，等父进程向管道写入命令
  //然后父进程执行下面的父进程的写入命令的代码，我们每写一个命令，就是向对应管道写入数据，然后对应管道的子进程读入，执行任务
  //打个比方，就是说，我们此时父进程所控制的管道内是空的，是空的，所以对于管道的子进程就是堵塞(在读命令，因为管道内没数据)
  //此时我们父进程发送一个任务码给管道，让对应子进程读到了，那么该子进程执行该任务，此时还是堵塞的，(为什么呢，是因为我们的写端还没关闭，我们的读端就默认一直在等待命名，一直堵塞在那)
  //所以执行不了std::cout<<"子进程等待命令终于结束了，阻塞的好累"<<std::endl;
  
  //2.我们写成自动化的，也可以搞成交互式的
  CtrlProcess(end_point);
  WaitChild(end_point);
  return 0;
}

现象1

其实我们创建完所以子进程的时候，我们的子进程一直处在堵塞状态(等待接受命令)

 只有当我们回收之后所有子进程后，所有子进程就会立马执行这个命令

回收后 

现象2

 理解所有子进程会继承父进程写端的时候再来看下面！！！

 怎么回收？

关闭所有写端！！！

方法1：倒着回收

 方法2：

 代码中实现的就是方法2，看注释

那为什么读端是一样的？

"写端不同，读端相同"是一个和匿名管道有关的表述，主要是指当使用匿名管道时，父进程和多个子进程之间的通信方式。
在这种情况下，父进程会往管道中写入数据，而多个子进程则可以从同一个管道中读取数据进行处理。因此，从子进程的角度来看，读取数据的管道文件描述符都是相同的。
但对于父进程来说，它需要向多个不同的管道中写入数据，以便控制多个不同的子进程并发执行任务。所以从父进程的角度来看，写入数据的管道文件描述符是不同的。
因此，"写端不同，读端相同"的表述中，是从两种进程的角度来描述匿名管道的特性。在这种通信方式下，需要注意管道的缓存限制，防止写入数据超过缓存大小而导致阻塞，同时在完成任务后要关闭掉管道文件描述符。