【Linux C | 网络编程】进程池退出的实现详解（五）

上一篇中讲解了在进程池文件传输的过程如何实现零拷贝，具体的方法包括使用mmap，sendfile，splice等等。

【Linux C | 网络编程】进程池零拷贝传输的实现详解（四）

这篇内容主要讲解进程池如何退出。

1.进程池的简单退出

进程池的简单退出要实现功能很简单，就是让父进程收到信号之后，再给每个子进程发送信号使其终止，这种实现方案只需要让父进程在一个目标信号（通常是10 信号 SIGUSR1 ）的过程给目标子进程发送信号即可。

在实现的过程需要注意的是 signal 函数和 fork 函数之间调用顺序，因为父进程会修改默认递送行为，而子进程会执行默认行为，所以 fork 应该要在 signal 的前面调用。

processData_t *workerList;//需要改成全局变量
int workerNum;
void sigFunc(int signum){
    printf("signum = %d\n", signum);
    for(int i = 0; i < workerNum; ++i){
        kill(workerList[i].pid,SIGUSR1);
    }
    for(int i = 0; i < workerNum; ++i){
        wait(NULL);
    }
    puts("process pool is over!");
    exit(0);
}
int main(){
//..
    makeChild(workerList,workerNum);
    signal(SIGUSR1,sigFunc);
    //注意fork和signal的顺序
}

2.使用管道通知工作进程终止

采用信号就不可避免要使用全局变量，因为信号处理函数当中只能存储有限的信息，有没有办法避免全局的进程数量和进程数组呢？ 一种解决方案就是采取“ 异步拉起同步 ” 的策略：虽然还是需要创建一个管道全局变量，但是该管道只用于处理进程池退出，不涉及其他的进程属性。这个管道的读端需要使用IO多路复用机制管理起来，而当信号产生之后，主进程递送信号的时候会往管道中写入数据，此时可以依靠 epoll 的就绪事件，在事件处理中来完成退出的逻辑。

异步执行与同步执行的区别

• 异步执行：异步操作是指当一个任务开始执行后，控制流可以继续执行下一个任务，而不需要等待当前任务完成。异步操作通常会通过回调函数、事件驱动机制或者Promise等方式来处理结果或通知任务的完成状态。在异步操作中，调用者通常不会立即等待操作的完成。

• 同步执行：同步操作是指一个任务开始执行后，调用者会一直等待任务完成，然后才能继续执行下一个任务。同步操作的执行顺序是按照代码的顺序依次执行的，直到当前任务完成。

异步拉起同步的应用场景和解释

异步拉起同步通常用来描述这样一种情况：

1. 异步任务的启动：首先，某个操作或任务以异步的方式启动，这意味着调用者可以在任务启动后继续执行其他操作，而不必等待任务完成。

2. 同步任务的结束：随后，在异步任务执行完毕后，系统或程序需要在某个点上进行同步操作，即等待这个异步任务完成并获取其结果，然后才能继续执行依赖于该结果的下一步操作。

进程池退出中的异步拉起同步的具体流程

1. 异步提交任务：主进程使用进程池异步地提交多个任务给子进程执行。这些任务可以是函数、方法或者其他可调用对象。

2. 任务执行：进程池管理器负责分配任务给空闲的子进程，并在子进程完成任务后收集返回的结果。

3. 等待任务完成：一旦主进程不再提交新任务到进程池，它需要等待所有已提交的任务都完成。这时候，主进程通常会发出一个信号或者事件，表示进程池应该开始进入退出状态。

4. 异步转同步：进程池收到退出信号后，开始等待所有任务完成。此时，进程池中的子进程继续处理它们的任务，主进程则通过某种机制（例如等待事件或轮询任务状态）来异步地等待所有子进程的任务完成。

5. 进程池退出：一旦所有任务完成，进程池中的子进程会被优雅地退出。主进程也可以在这个时候执行一些清理工作，例如关闭文件、释放资源等。

简单点总结就是：

信号 + 匿名管道  =》 异步拉起同步

1. SIGUSR1  父进程获取信号后，在信号处理函数中，通过匿名管道进入epoll

2. 在epoll循环中，有两种方式让子进程退出     

A. 在父进程中，直接调用kill函数，给子进程发送SIGUSR1信号（粗暴）     

B. 在父进程中，通过sendFd函数，通知子进程退出（温和）在子进程中，通过recvFd函数，获取到退出标志位，然后退出，可以确保每一个任务都能够执行完毕。

粗暴的退出代码：

#include "process_pool.h"

//退出使用的匿名管道
int exitPipe[2];

void sighandler(int signum)
{
    printf("signum %d is coming.\n", signum);
    int one = 1;
    //父进程收到信号，往管道写端写入数据
    write(exitPipe[1], &one, sizeof(one));
}

int main(int argc, char ** argv)
{
    //ip port processnum
    ARGS_CHECK(argc, 4);
    int processNum = atoi(argv[3]);
    process_data * pProcess = calloc(processNum, sizeof(process_data));
    //让父子进程都忽略掉SIGPIPE信号
    //signal(SIGPIPE, SIG_IGN);
    //创建N个子进程
    makeChild(pProcess, processNum);
    //makechild函数之后，都是父进程的操作

    //在父进程中注册信号处理函数
    signal(SIGUSR1, sighandler);

    //只在父进程中创建退出的管道
    pipe(exitPipe);

    //创建监听的服务器
    int listenfd = tcpInit(argv[1], atoi(argv[2]));

    //创建epoll的实例
    int epfd = epoll_create1(0);
    ERROR_CHECK(epfd, -1, "epfd");
    //epoll监听Listenfd
    epollAddReadEvent(epfd, listenfd);
    //epoll监听进程池退出的管道读端exitPipe[0]，
    epollAddReadEvent(epfd, exitPipe[0]);
    ///epoll监听父子进程间通信的管道
    for(int i = 0; i < processNum; ++i) {
        epollAddReadEvent(epfd, pProcess[i].pipefd);
    }
    //定义保存就绪的文件描述符的数组
    struct epoll_event eventArr[10] = {0};
    int nready = 0;

    while(1)
    {
        nready = epoll_wait(epfd, eventArr, sizeof(eventArr), -1);
        for(int i = 0; i < nready; ++i) {
            int fd = eventArr[i].data.fd; 
            //新客户端到来
            if(fd == listenfd) {
                struct sockaddr_in clientaddr;
                socklen_t len = sizeof(clientaddr);
                int peerfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
                ERROR_CHECK(peerfd, -1, "accept");
                printf("client %s:%d connected.\n",
                       inet_ntoa(clientaddr.sin_addr), ntohs(clientaddr.sin_port));
                //将peerfd发送给一个空闲的子进程
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].status == FREE) {
                        sendFd(pProcess[j].pipefd, peerfd);
                        pProcess[j].status = BUSY;
                        break;
                    }
                }
                //如果要断开与客户端的连接，这里还得执行一次
                close(peerfd);
            } else if(fd == exitPipe[0])  {     //匿名管道读端有数据，说明父进程收到退出的信号，循环给子进程发出退出信号
                int howmany = 0;
                read(fd, &howmany, sizeof(howmany));
                //处理进程池退出的情况
                //第一种方式： 父进程给子进程发送SIGUSR1信号
                for(int j = 0; j < processNum; ++j) {
                    kill(pProcess[j].pid, SIGUSR1);
                }

                for(int j = 0; j < processNum; ++j) {
                    wait(NULL);
                }
                goto end;
            } else {
                //管道发生了事件: 子进程已经执行完任务了
                int howmany = 0;
                read(fd, &howmany, sizeof(howmany));
                for(int j = 0; j < processNum; ++j) {
                    if(pProcess[j].pipefd == fd) {
                        pProcess[j].status = FREE;
                        printf("child %d is not busy.\n", pProcess[j].pid);
                        break;
                    }
                }

            }
        }
    }
end:
    printf("exit process pool.\n");
    free(pProcess);
    close(exitPipe[0]);
    close(exitPipe[1]);
    close(listenfd);
    close(epfd);
    return 0;
}

3.优雅退出

上述的退出机制存在一个问题，就是即使工作进程正在传输文件中，父进程也会通过信号将其终止。如何实现进程池在退出的时候，子进程要完成传输文件的工作之后才能退出呢？

一种典型的方案是使用 sigprocmask 在文件传输的过程中设置信号屏蔽字，这样可以实现上述的机制。

另一种方案就是调整 sendFd 的设计，每个工作进程在传输完文件之后总是循环地继续下一个事件，而在每个事件处理的开始，工作进程总是会调用 recvFd 来使自己处于阻塞状态直到有事件到达。我们可以对进程池的终止作一些调整：用户发送信号给父进程表明将要退出进程池；随后父进程通过 sendFd给所有的工作进程发送终止的信息，工作进程在完成了一次工作任务了之后就会 recvFd 收到进程池终止的信息，然后工作进程就可以主动退出；随着所有的工作进程终止，父进程亦随后终止，整个进程池就终止了。

int sendFd(int pipeFd, int fdToSend, int exitFlag){
    struct msghdr hdr;
    bzero(&hdr,sizeof(struct msghdr));
    struct iovec iov[1];
    iov[0].iov_base = &exitFlag;
    iov[0].iov_len = sizeof(int);
    hdr.msg_iov = iov;
    hdr.msg_iovlen = 1;
    //...
}
int recvFd(int pipeFd, int *pFd, int *exitFlag){
    struct msghdr hdr;
    bzero(&hdr,sizeof(struct msghdr));
    struct iovec iov[1];
    iov[0].iov_base = exitFlag;
    iov[0].iov_len = sizeof(int);
    hdr.msg_iov = iov;
    hdr.msg_iovlen = 1;
    //.....
}