一个简单的多进程服务器（包含fork()讲解）

一个简单的多进程服务器（包含fork()讲解）

1. 重要的 fork()函数

​ fork函数用于创建一个与当前进程映像一样的子进程，所创建的子进程将复制父进程的代码段、数据段、BSS段、堆、栈等所有用户空间信息，在内核中操作系统会重新为其申请一个子进程执行的位置。

​ fork系统调用会通过复制一个现有进程来创建一个全新的进程，新进程被存放在一个叫做任务队列的双向循环链表中，链表中的每一项都是类型为task_struct的进程控制块PCB的结构。
​ 在不同的UNIX系统下，是无法确定fork后是子进程先运行还是父进程先运行，这依赖于系统的实现在不同的UNIX系统下，是无法确定fork后是子进程先运行还是父进程先运行，这依赖于系统的实现。

经典例子1：

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
int main(int argc, char ** argv )
{
         int i;
         for(i = 0;i < 2;i++)
         {
               fork();
               printf("%d, i am parent: PPID:%d, i am child: PID:%d\n",i,getppid(),getpid());
               sleep(1);
         }
}

执行结果如下：

0, i am parent: PPID:526049, i am child: PID:526243
0, i am parent: PPID:526243, i am child: PID:526244
1, i am parent: PPID:526049, i am child: PID:526243
1, i am parent: PPID:526243, i am child: PID:526247
1, i am parent: PPID:526243, i am child: PID:526244
1, i am parent: PPID:526244, i am child: PID:526248

将for循环中的 i < 2 改成 i < 3，结果如下：

0, i am parent: PPID:526049, i am child: PID:526279
0, i am parent: PPID:526279, i am child: PID:526280
1, i am parent: PPID:526279, i am child: PID:526280
1, i am parent: PPID:526049, i am child: PID:526279
1, i am parent: PPID:526279, i am child: PID:526283
1, i am parent: PPID:526280, i am child: PID:526284
2, i am parent: PPID:526049, i am child: PID:526279
2, i am parent: PPID:526279, i am child: PID:526280
2, i am parent: PPID:526280, i am child: PID:526284
2, i am parent: PPID:526279, i am child: PID:526283
2, i am parent: PPID:526279, i am child: PID:526288
2, i am parent: PPID:526283, i am child: PID:526290
2, i am parent: PPID:526280, i am child: PID:526287
2, i am parent: PPID:526284, i am child: PID:526289

​ 可以看出，调用n次 fork 函数，最终出来的总进程数量是 pow(2, n)，像一个二叉树一样。

经典例子2：

//example1
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main(void)
{
        int i;
        for(i=0;i<2;i++)
        {
                fork();
                printf("-");
        }
        return 0;
}

//example2
#include<stdio.h>
#include<sys/types.h>
#include<unistd.h>
int main(void)
{
        int i;
        for(i=0;i<2;i++)
        {
                fork();
                printf("-\n");
        }
        return 0;
}

下面直接给出结果：

第一个程序将打印出8个 - ，第二个程序将打印出6个 - 。

考察点1：Linux缓冲机制，当printf遇到还行符号的时候才会打印。

考察点2：fork行为，第一，当fork调用的时候会返回两次，分别在父进程和子子进程中，父线程中返回子进程的pid，而子进程中返回0，表示执行成功。同时，子进程和父进程的执行位置都是fork之后的语句。子进程执行成功后，他的行为是拷贝父进程的数据区，其中就包括缓冲区。

​ 解释：当i=0，的时候，创建一个新的进程，这时候有两个进程，但是因为父进程中的缓冲区并没有内容，所以子进程缓冲区中也没有数据。第一次循环结束，两个进程中的缓冲区分别存放了一个“-”，但是没有输出哈。当 i=1 的时候，两个进程中都进行fork，那么结果就会有四个进程，新创建的两个进程都拷贝父进程的缓冲区，这时每个进程中的缓冲区存放一个“-”。同时四个进程都执行fork后的语句，printf，四个进程中各有两个“-”。这样，在循环结束之后，程序结束之前，要清理缓冲区，所以每个进程输出两个“-”，加起来就是有8个。

​ 但是如果在printf中加了回车符号的话，那么在i=0,循环结束之后，两个进程的缓冲区都没有内容，因为遇到还行符号输出了。当i=1，的时候，各个进程又往自己的缓冲区中放了一个’’-",所以一共有六个。

2. 多进程服务器实现

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>
#include <errno.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>

#include "wrap.h"

#define SRV_PORT 9999

void catch_child(int signum)
{
    while ((waitpid(0, NULL, WNOHANG)) > 0);
    return ;
}

int main(int argc, char *argv[])
{
    int lfd, cfd;
    pid_t pid;
    struct sockaddr_in srv_addr, clt_addr;
    socklen_t clt_addr_len; 
    char buf[BUFSIZ];
    int ret, i;

    //memset(&srv_addr, 0, sizeof(srv_addr));                 // 将地址结构清零
    bzero(&srv_addr, sizeof(srv_addr));

    srv_addr.sin_family = AF_INET;
    srv_addr.sin_port = htons(SRV_PORT);
    srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

    lfd = Socket(AF_INET, SOCK_STREAM, 0);

    Bind(lfd, (struct sockaddr *)&srv_addr, sizeof(srv_addr));

    Listen(lfd, 128);

    clt_addr_len = sizeof(clt_addr);

    while (1) {

        cfd = Accept(lfd, (struct sockaddr *)&clt_addr, &clt_addr_len);

        pid = fork();
        if (pid < 0) {
            perr_exit("fork error");
        } else if (pid == 0) {
            close(lfd);
            break;        
        } else {
            struct sigaction act;

            act.sa_handler = catch_child;
            sigemptyset(&act.sa_mask);
            act.sa_flags = 0;

            ret = sigaction(SIGCHLD, &act, NULL);
            if (ret != 0) {
               perr_exit("sigaction error");
            }
            close(cfd); 
            continue;
        }
    }

    if (pid == 0) {
        for (;;) {
            ret = Read(cfd, buf, sizeof(buf));
            if (ret == 0) {
                close(cfd);
                exit(1);
            } 

            for (i = 0; i < ret; i++)
                buf[i] = toupper(buf[i]);

            write(cfd, buf, ret);
            write(STDOUT_FILENO, buf, ret);
        }
    }
    return 0;
}

​ 实现思路：首先还是老一套（socket、bind、listen），在while(1)循环中先调用accept，整个进程阻塞在accept中进而等待客户端建立连接。一旦有客户端连接上，紧接着调用fork系统函数创建子进程，父进程与子进程均开始执行fork()下面的代码。

​ 怎么避免僵尸进程？也就是怎么正常的终止进程？僵尸进程的两个原因，一是父进程先于子进程终止（被init进程领养）；二是子进程先于主进程终止。

​ 当子进程正常或异常终止时，系统内核向其父进程发送SIGCHLD信号，并提供一个该信号发生时被调用的函数。本段代码中，父进程中编写了一个信号捕捉函数，该函数只做一件事，即等待子进程执行完毕，然后回收子进程。子进程中，就一直读取套接字里面的数据，并将其小写改成大写，同时将完成的逻辑写到套接字和终端上。

​ 说明：产生新的子进程之后，父进程需要关闭连接套接字，而子进程需要关闭监听套接字。原因如下：

• 关闭不需要的套接字可以节省系统资源，同时可避免父子进程共享这些套接字可能带来的不可预计的后果。
• 更重要的是，为了正确连接关闭连接。和文件描述符一样，每个套接字描述符都有一个引用计数。当fork返回后，listenfd和connfd的引用计数变成2，而系统只有在某描述符的引用计数为0时，才真正关闭该socket。

注：wrap.h的函数签名及其实现在上一篇文章中已实现出来，参考链接。

Ref[1]: https://www.jianshu.com/p/c9d0fab9516d

Ref[2]: https://blog.csdn.net/zzran/article/details/8026151?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf

Ref[3]: https://www.bilibili.com/video/BV1iJ411S7UA?p=39 “Linux网络编程 --黑马程序员”