本文使用 fork 函数实现并发 TCP 服务器,关于 fork 函数的用法可以参考我的文章:Linux 下的 fork 和 exec 函数。

服务器基本结构

本文的目标是编写一个完整的 TCP 客户/服务器程序示例。这个简单的例子是执行如下步骤的一个回射服务器:

(1) 客户从标准输入读入一行文本,并写给服务器;
(2) 服务器从网络输入读入这行文本,并回射给客户;
(3) 客户从网络输入读入这行回射文本,并显示在标准输出上。

image

迭代服务器和并发服务器

迭代服务器以串行方式一次处理一个客户端。迭代服务器会依次处理客户端的连接,只要当前连接的任务没有完成,服务器的进程就会被一直占用,直到任务完成后,服务器关闭这个 socket,释放连接。

并发服务器可以同时并行处理多个客户端。并发服务器主要通过三种方式实现:进程、线程和 IO 复用。

迭代服务器程序轮廓

int listenfd, connfd;

listenfd = socket(AF_INET, SOCK_STREAM, 0);
bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
listen(listenfd, LISTENQ);

for (;;) {
    connfd = accept(listenfd, (struct sockaddr*)&client_addr, &client_len);
    doit(connfd);          // 处理客户端请求
    close(connfd);         // 关闭连接,等待下一个客户端
}

并发服务器程序轮廓

pid_t pid;
int listenfd, connfd;

listenfd = socket(AF_INET, SOCK_STREAM, 0);
bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
listen(listenfd, LISTENQ);

for (;;) {
    connfd = accept(listenfd, (struct sockaddr*)&client_addr, &client_len);
    if ((pid = fork()) == 0) {
        // 子进程:处理客户端请求
        close(listenfd);
        doit(connfd);
        close(connfd);
        exit(0);
    }
    // 父进程:关闭连接,继续等待新连接
    close(connfd);
}

并发服务器的运行流程

我们在同一个主机上启动客户,并指定服务器主机的 IP 地址为 127.0.0.1(环回地址)。当然我们也可以指定该地址为该主机的普通(非环回)IP 地址。

客户调用 socket 和 connect,后者引起 TCP 的三路握手过程。当三路握手完成后,客户中的 connect 和服务器中的 accept 均返回,连接于是建立。接着发生的步骤如下:

(1) 客户调用 send 函数,该函数将阻塞于 fgets 调用,因为我们还未曾键入过一行文本。

(2) 当服务器中的 accept 返回时,服务器调用 fork,再由子进程调用 write 函数返回输入信息。调用 read,而 read 在等待客户送入一行文本期间阻塞。

(3) 另一方面,服务器父进程再次调用 accept 并阻塞,等待下一个客户连接。

至此,我们有 3 个都在睡眠(即已阻塞)的进程:客户进程、服务器父进程和服务器子进程。

至此连接已经建立,不论我们在客户的标准输入中键入什么,都会回射到它的标准输出中。

POSIX 信号处理

信号(signal)就是告知某个进程发生了某个事件的通知,有时也称为软件中断(software interrupt)。信号通常是异步发生的,也就是说进程预先不知道信号的准确发生时刻。

信号可以:

  • 由一个进程发给另一个进程(或自身);
  • 由内核发给某个进程。

上一节结尾提到的 SIGCHLD 信号就是由内核在任何一个进程终止时发给它的父进程的一个信号。

(1) 每个信号都有一个与之关联的处置(disposition),也称为行为(action)。我们通过调用 sigaction 函数来设定一个信号的处置,并有三种选择。

我们可以提供一个函数,只要有特定信号发生它就被调用。这样的函数称为信号处理函数(signal handler),这种行为称为捕获(catching)信号。有两个信号不能被捕获,它们是 SIGKILL 和 SIGSTOP。信号处理函数由信号值这个单一的整数参数来调用,且没有返回值,其函数原型如下:

void handler(int signo);

对于大多数信号来说,调用 sigaction 函数并指定信号发生时所调用的函数就是捕获信号所需做的全部工作。

(2) 我们可以把某个信号的处置设定为 SIG_IGN 来忽略(ignore)它。SIGKILL 和 SIGSTOP 这两个信号不能被忽略。

(3) 我们可以把某个信号的处置设定为 SIG_DFL 来启用它的默认(default)处置。默认处置通常是在收到信号后终止进程,其中某些信号还在当前工作目录产生一个进程的核心映像(core image,也称为内存影像)。另有个别信号的默认处置是忽略,SIGCHLD 和 SIGURG(带外数据到达时发送)就是默认处置为忽略的两个信号。

signal 函数

建立信号处置的 POSIX 方法就是调用 sigaction 函数。不过这有点复杂,因为该函数的参数之一是我们必须分配并填写的结构。简单些的方法就是调用 signal 函数,其第一个参数是信号名,第二个参数或为指向函数的指针,或为常值 SIG_IGN 或 SIG_DFL。然而 signal 是早于 POSIX 出现的历史悠久的函数。调用它时,不同的实现提供不同的信号语义以达成后向兼容,而 POSIX 则明确规定了调用 sigaction 时的信号语义。我们的解决办法是定义自己的 signal 函数,它只是调用 POSIX 的 sigaction 函数。这就以所期望的 POSIX 语义提供了一个简单的接口。

函数原型如下:

typedef void (*sighandler_t)(int);
sighandler_t signal(int sig, sighandler_t handler);

image

第二个参数是捕获到该信号的处理方式,这里我们选择自己定义对于信号的反应函数,即下文的处理僵死进程。

这里我们选择使用 SIGCHLD 信号。(其他信号类型和作用,这里就不作赘述了)

其作用是:进程 Terminate 或 Stop 的时候,SIGCHLD 会发送给它的父进程。缺省情况下该信号会被忽略。

如何处理 SIGCHLD 信号

设置僵尸(zombie)状态的目的是维护子进程的信息,以便于父进程在某个时刻获取。这里面包含:子进程的进程 ID、终止状态以及资源利用信息(CPU 时间、内存使用量)。如果一个进程终止,而该进程有子进程处于僵尸状态,那么它的所有僵尸子进程的父进程会变成 init 进程,进程 ID=1。init 进程会清理(wait)这些僵尸进程。

处理僵死进程

我们显然不愿意留存僵死进程。它们占用内核中的空间,最终可能导致我们耗尽进程资源。无论何时我们 fork 子进程都得 wait 它们,以防它们变成僵死进程。为此我们建立一个俘获 SIGCHLD 信号的信号处理函数,在函数体中我们调用 wait。

signal(SIGCHLD, sig_chld);

我们就建立了该信号处理函数。(这必须在 fork 第一个子进程之前完成,且只做一次。)我们接着定义名为 sig_chld 的这个信号处理函数:

void sig_chld(int signo) {
    pid_t pid;
    int stat;

    while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        printf("child %d terminated\n", pid);
    }
    return;
}

wait 和 waitpid 函数

#include <sys/wait.h>
pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);
// 均返回:若成功则为进程 ID,若出错则为 0 或 -1

wait 函数的原理

进程调用 wait,然后阻塞自己,然后寻找僵尸子进程,找到了则销毁子进程然后返回,没有找到则一直阻塞直到找到僵尸子进程为止。

waitpid 函数

pid 参数

(1) pid > 0:只等待进程 ID 等于 pid 的子进程,不管其它已经有多少子进程运行结束退出了,只要指定的子进程还没有结束,waitpid 就会一直等下去。

(2) pid = -1:等待任何一个子进程,没有限制,此时和 wait 函数作用一模一样。

(3) pid < -1:等待一个指定进程组中的任何子进程,进程组号 = pid 的绝对值。

(4) pid = 0:等待一个指定进程组中的任何子进程,进程组号为 pid 的值。

options 参数

(1) options = WNOHANG:即使子进程没有退出,它也会立即返回,不会像 wait 那样永远等下去。

(2) options = WUNTRACED:子进程睡眠则马上返回,但结束状态不予理会。

(3) options = 0:不使用该参数。和 wait 函数相比,waitpid 其实是 wait 函数的封装,waitpid 可以指定等待的子进程,并且指定返回的条件。

wait 和 waitpid 函数的用法

函数 wait 和 waitpid 均返回两个值:已终止子进程的进程 ID 号,以及通过 statloc 指针返回的子进程终止状态(一个整数)。

我们可以调用三个宏来检查终止状态,并辨别子进程是正常终止、由某个信号杀死还是仅仅由作业控制停止而已。另有些宏用于接着获取子进程的退出状态、杀死子进程的信号值或停止子进程的作业控制信号值。

如果调用 wait 的进程没有已终止的子进程,不过有一个或多个子进程仍在执行,那么 wait 将阻塞到现有子进程第一个终止为止。

waitpid 函数就等待哪个进程以及是否阻塞给了我们更多的控制。首先,pid 参数允许我们指定想等待的进程 ID,值 -1 表示等待第一个终止的子进程。其次,options 参数允许我们指定附加选项。最常用的选项是 WNOHANG,它告知内核在没有已终止子进程时不要阻塞。

wait 和 waitpid 的区别

waitpid 采用了 WNOHANG 参数,所以 waitpid 不会阻塞,也就是说父进程不会阻塞在那里等待子进程返回,它会立即返回然后去做自己的事情,所以需要加个循环直到等待到进程为止,相当于轮询。

而在一些情况下,比如同一信号多个实例的递交,建立一个信号处理函数并在其中调用 wait 并不足以防止出现僵死进程。

正确的解决办法是调用 waitpid 而不是 wait。原因在于,我们在一个循环内调用 waitpid,以获取所有已终止子进程的状态。我们必须指定 WNOHANG 选项,它告知 waitpid 在有尚未终止的子进程在运行时不要阻塞。我们不能在循环内调用 wait,因为没有办法防止 wait 在正运行的子进程尚有未终止时阻塞。

并发 TCP 服务器代码实现

server.cpp

#include <iostream>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cstring>
#include <signal.h>
#include <sys/wait.h>
#include <errno.h>

#define PORT 8888
#define BUFFER_SIZE 1024

// SIGCHLD 信号处理函数:回收僵死子进程
void sig_chld(int signo) {
    pid_t pid;
    int stat;
    while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {
        std::cout << "child " << pid << " terminated" << std::endl;
    }
    return;
}

int main() {
    int listenfd, connfd;
    struct sockaddr_in server_addr, client_addr;
    socklen_t client_len = sizeof(client_addr);
    char buffer[BUFFER_SIZE];

    // 创建 socket
    listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (listenfd < 0) {
        perror("socket error");
        return -1;
    }

    // 设置地址复用,防止 "Address already in use"
    int opt = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 绑定地址
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(PORT);

    if (bind(listenfd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        perror("bind error");
        return -1;
    }

    // 监听
    if (listen(listenfd, 10) < 0) {
        perror("listen error");
        return -1;
    }

    // 捕获 SIGCHLD 信号,防止僵尸进程
    signal(SIGCHLD, sig_chld);

    std::cout << "server running on port " << PORT << std::endl;

    // 接受客户端连接
    while (true) {
        connfd = accept(listenfd, (struct sockaddr*)&client_addr, &client_len);
        if (connfd < 0) {
            if (errno == EINTR) {
                // 被信号中断,继续等待
                continue;
            }
            perror("accept error");
            break;
        }

        std::cout << "new connection from " << inet_ntoa(client_addr.sin_addr)
                  << ":" << ntohs(client_addr.sin_port) << std::endl;

        // 创建子进程处理客户端请求
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork error");
            close(connfd);
            continue;
        }

        if (pid == 0) {
            // 子进程:处理客户端请求
            close(listenfd);

            ssize_t n;
            while ((n = read(connfd, buffer, BUFFER_SIZE)) > 0) {
                write(connfd, buffer, n);   // 回射数据
            }

            close(connfd);
            std::cout << "client disconnected" << std::endl;
            exit(0);
        }

        // 父进程:关闭连接,继续等待新连接
        close(connfd);
    }

    close(listenfd);
    return 0;
}

编译与运行

# 编译服务器程序
g++ -o server server.cpp

# 运行服务器
./server

测试方法

在另一个终端中使用 telnet 或 nc 命令进行测试:

# 使用 telnet 测试
telnet 127.0.0.1 8888

# 或使用 nc 测试
nc 127.0.0.1 8888

连接后输入任意字符,服务器会将输入的内容回射到终端。同时打开多个终端连接,可以验证服务器并发处理多个客户端的能力。

客户端程序

客户端程序可以参考我的另一篇文章:计算机网络知识点总结(三)Socket 基本函数详解,C++ Socket 入门实战。

Logo

汇聚全球AI编程工具,助力开发者即刻编程。

更多推荐