TCP/IP网络编程 -- （十）多进程服务器端

10.1进程概念及应用

为了提高客户端的平均满意度，通常会使用并发服务器的方法，并且网络程序中数据通信时间比 CPU 运算时间大，因此向多个客户端提供服务是一种有效利用 CPU 的方式

主要有三种方法：

多进程服务器：通过创建多个进程提供服务

多路复用服务器：通过捆绑并统一管理 I/O 对象提供服务

多线程服务器：通过生成与客户端等量的线程提供服务

理解进程

进程：占用内存空间的正在运行的程序

ps 命令可查看当前运行的所有进程（ps au）

通过调用 fork 函数创建进程

#include <unistd.h>
pid_t fork(void);

成功时返回进程ID，失败返回 -1

创建的为当前进程的副本，两个进程都将执行 fork 函数返回后的语句

但是因为是同一个进程复制相同的内存空间得到的新进程，所以之后的程序流程要根据 fork 的返回值加以区分

父进程：fork 返回子进程 ID

子进程：fork 返回 0

复制进程后 gval 与 lval 在两个进程后是独立的，只是共享同一份代码

10.2进程与僵尸进程

进程执行完 main 函数中的程序应该被销毁，但有时会变成僵尸进程，占用系统重要资源。

产生僵尸进程的原因

终止子进程只有通过下面两种方式

传递参数并调用 exit()
main 函数中执行 return

exit 中的参数或 main 函数返回值都会传给操作系统，但是并不会销毁进程，直到把这些值传给父进程，这样的状态下的进程就是僵尸进程

但是操作系统不会自动将这些值传给父进程，而是在父进程主动发起函数调用时才会获取这些值（父母要负责收回自己的孩子，操作系统并不负责）

销毁僵尸进程1：利用 wait 函数

#include <sys/wait.h>
pid_t wait(int *statloc)

成功时返回终止的子进程 ID，失败返回 -1

子进程终止时传递的返回值将会保存在 statloc 所致的内存空间中，但是还包含了其他信息，需要通过下面的宏来分离

int *status;
wait(status);
if (WIFEXITED(status))//正常终止返回 true
{
    puts("Normal termination");
    printf("Child pass num: %d", WEXITSTATUS(status));// WEXISTTATUS 返回子进程的返回值
}

销毁僵尸进程2：使用 waitpid 函数

wait 函数会引起程序阻塞，如果当前没有子进程终止，父进程会阻塞在这里

#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *statloc, int options)

成功时返回终止的子进程 ID，失败返回 -1

pid：等待终止目标子进程的 ID，若传递 -1，则和 wait 一样是等待任意子进程终止

statloc：保存返回值的指针，和 wait 函数相同

option：若传递常量 WNOHANG，则即使目标子进程没有终止，也不会阻塞等待，而是返回 0 并退出

10.3信号处理

父进程不能一直调用 waitpid 函数来等待子进程终止，但是操作系统知道子进程何时终止的，最好操作系统可以给父进程传递一个信号来告诉子进程终止了

流程为：

父进程告诉操作系统：如果创建的子进程终止，就帮我调用 zombie_handler 函数

操作系统回复：我可以帮你调用，但是你要先把 zombie_handler 函数编好

相当于父进程需要先注册信号，子进程结束后操作系统直接可以调用

#inlclude <signal.h>
void (*signal(int signo, void(*func)(int)))(int);

函数名：signal

参数：int signo, void(* func)(int)

返回类型：参数为 int，返回 void 型函数指针

alarm 函数

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

若传递 t，表示 t 秒后将产生 SIGALRM 信号；传递 0，表示之前对 SIGALRM 的预约取消

信号常量：

SIGALRM：已到通过调用 alarm 函数注册的时间

SIGINT：输入了 ctrl + C

SIGCHLD：子进程终止

事例：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig)
{
    if (sig == SIGALRM)//其实是不用写 if 的，这里是一个类似 assert 的功能
        puts("Time out");
    alarm(2);
}

void keycontrol(int sig)
{
    if (sig == SIGINT)
        puts("CTRL + C pressed");
}

int main()
{
    signal(SIGALRM, timeout);
    signal(SIGINT, keycontrol);
    alarm(2);

    for (int i = 0; i < 3; i++)
    {
        puts("wait...");
        sleep(100);
    }
    return 0;
}

利用 sigaction 函数进行信号处理

signal 在不同的 UNIX 系统中可能存在区别，但 sigactoin 函数完全相同

#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oldact);

成功返回 0，失败返回 -1

signo：与 signal 相同，传递信号信息

act：对应第一个参数信号的处理信息

oldact：获取之前的处理信息的指针，如果不需要则传递 0

struct sigaction
{
	void (*sa_handler)(int);
    sigset_t sa_mask; //一般情况用 sigemptyset(&act.sa_mask) 置0即可
    int sa_flags;//一般情况置0
};

#include <stdio.h>
#include <unistd.h>
#include <signal.h>


void timeout(int sig)
{
    if (sig == SIGALRM)
        puts("Time out");
    alarm(2);
}

int main()
{
    struct sigaction act;
    act.sa_handler = timeout;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGALRM, &act, 0);
    alarm(2);
    for (int i = 0; i < 3; i++)
    {
        puts("wait...");
        sleep(100);
    }
    return 0;
}

基于进程的并发服务器模型

每当有客户端请求服务时，服务器都创建一个子进程提供服务，分为三个阶段

服务器（父进程）通过调用 accept 函数受理连接请求
获取 socket 文件描述符，创建子进程，并把文件描述符传递给子进程
子进程利用传递来的文件描述符提供服务

其实不需要把文件描述符传递给子进程，因为子进程有和父进程一样的资源

多进程并发服务器

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

const int BUF_SIZE = 30;

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

void read_childproc(int sig)
{
    pid_t pid;
    int status;
    pid = waitpid(-1, &status, WNOHANG);
    printf("removed proc id: %d \n", pid);
}
int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;

    pid_t pid;
    struct sigaction act;
    socklen_t adr_sz;
    int str_len, state;
    char buf[BUF_SIZE];

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }
    //注册当子进程终止时父进程的处理
    act.sa_handler = read_childproc;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    state = sigaction(SIGCHLD, &act, 0);

    //初始化服务器
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));
    if (bind(serv_sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    while(1)
    {
        adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
        if (clnt_sock == -1)
            continue;
        else
            puts("new client connected...");
        pid = fork();
        //进程创建失败，但不知道为什么continue，当前循环的clnt_sock不处理了吗
        if (pid == -1)
        {
            close(clnt_sock);
            continue;
        }
        //子进程运行区域
        if (pid == 0)
        {
            close(serv_sock);
            while((str_len = read(clnt_sock, buf, BUF_SIZE)) != 0)
                write(clnt_sock, buf, str_len);
            close(clnt_sock);
            puts("client disconnected...");
            return 0;
        }
        else
            close(clnt_sock);
    }
    close(serv_sock);
    return 0;
}

注意在子进程运行开始执行了 close(serv_sock); 在创建子进程后也执行了 close(clnt_sock);

这是因为子进程复制 socket 后，同一个端口将对应多个 socket ，要关掉多余的 socket

其实上面的解释是有点问题的，因为 socket 不是进程的资源，而是操作系统的资源，并不会复制给子进程，但是会复制 socket 的文件描述符，这样就有两个文件描述符指向同一个 socket，只有当关闭所有的文件描述符才能关闭连接（类似于 shared_ptr）