多进程并发服务器

发表于 更新于 分类于 阅读次数：

我们来考虑有多个客户同时连接一个服务器的情况。在前面的TCP套接字编程的例子中，我们已经看到，服务器程序在接受来自客户端的一个新连接时，会创建出一个新的套接字（已连接套接字），而原先的监听套接字则继续监听后面的连接请求。如果服务器不能立刻接受后来的连接，它们将被放到队列中以等待处理。
原先的套接字仍然可用并且套接字的行为就像文件描述符，这一事实给我们提供了一种同时服务多个客户的方法。如果服务器调用fork为自己创建第二份副本，打开的套接字就将被新的子进程所继承。新的子进程可以和连接的客户进行通信，而主服务器进程可以继续接受以后的客户连接。

为了了解这是如何工作的，假设我们有两个客户端和一个服务器，服务器正在监听一个监听套接字（比如描述符3）上的连接请求。
现在假设服务器接受了客户端1的连接请求，并返回一个已连接套接字（比如描述符4），如图1所示。

图1：第一步：服务器接受客户端的连接请求

在接受连接请求后，服务器派生一个子进程，这个子进程获得服务器描述符表的完整拷贝。子进程关闭它的拷贝中的监听套接字（描述符为3），而父进程关闭它的已连接套接字（描述符为4）的拷贝，因为不需要这些描述符了。这就得到图2中的状态，其中的子进程正忙于为客户端提供服务。
因为父、子进程中的已连接套接字描述符都指向同一个文件表表项，所以父进程关闭它的已连接套接字描述符的拷贝是至关重要的。否则，将永远不会释放已连接套接字描述符4的文件表表项，这会导致存储器资源泄漏并将最终消耗尽可用的存储器，使系统崩溃。


图2：第二步：服务器派生一个子进程为这个客户端服务

现在，假设在父进程为客户端1创建了子进程后，它接受一个新的客户端2的连接请求，并返回一个新的已连接套接字（比如描述符5），如图3所示。


图3：第三步：服务器接受另一个连接请求

然后父进程又派生另一个子进程，这个子进程利用已连接套接字（描述符为5）为它的客户端提供服务，如图4所示。


图4：服务器派生另一个子进程为新的客户端服务

此时，父进程继续等待下一个连接请求，而两个子进程正在并发地为它们各自的客户端提供服务。

例子

我们现在来看下如何使用代码来实现多进程并发服务器。在编写代码时，有几点需要着重强调的：

  • 因为我们创建子进程，但并不等待子进程的完成，所以安排服务器忽略SIGCHLD信号以避免出现僵尸进程。
  • 父子进程必须关闭它们各自的已连接套接字拷贝，如上面所述，这样才能避免存储器资源泄漏。
  • 因为套接字的文件表项中的引用计数，直到父子进程的已连接套接字描述符都关闭了，到客户端的连接才会终止。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

int main() {
    int listenfd, connfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;

    // 创建套接字
    listenfd = socket(AF_INET, SOCK_STREAM, 0);

    // 命名套接字
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(6240);
    server_len = sizeof(server_address);
    bind(listenfd, (struct sockaddr*)&server_address, server_len);

    // 创建套接字队列
    listen(listenfd, 5);

    // 避免出现僵尸进程
    signal(SIGCHLD, SIG_IGN);

    // 接受客户连接
    while (1) {
        char ch;
        printf("server waiting\n");

        client_len = sizeof(client_address);
        connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_len);

        // 创建子进程，为这个客户创建一个子进程，并判断当前是运行是在父进程还是在子进程中
        if (fork() == 0) {
            // 在子进程中
            close(listenfd);
            read(connfd, &ch, 1);
            ch++;
            write(connfd, &ch, 1);
            close(connfd);
            sleep(5);
            printf("subprocess, ch: %d, exit\n", ch);
            exit(0);
        } else {
            // 在父进程中
            close(connfd);
        }
    }
}

运行上面的代码，然后使用客户端测试程序（见本文附录）来测试多进程并发服务器的实现。
运行客户端程序：

$ ./client3 & ./client3 & ./client3

客户端终端输出：

char from server = B
char from server = B
char from server = B

同时，可以看到服务器程序输出：

server waiting
server waiting
server waiting
server waiting
subprocess, ch: 66, exit
subprocess, ch: 66, exit
subprocess, ch: 66, exit

多进程优劣

在父、子进程间共享状态信息，进程有一个非常清晰的模型：共享文件表，但是不共享用户地址空间。这样一来，一个进程不可能覆盖另一个进程的用户地址空间。这就消除了许多令人迷惑的错误。这是多进程实现并发服务器的优点。
另一方面，独立的地址空间使用进程共享状态信息变得困难，为了共享信息，必须使用IPC（进程间通信机制）。多进程的另一个缺点是，它们往往比较慢，因为进程控制和IPC的开销都较高。

参考资料

  1. 深入理解计算机系统，第2版，机械工业出版社
  2. Linux程序设计（第4版），Neil Matthew等著，人民邮电出版社，2010年
  3. UNIX 网络编程卷1：套接字联网API（第三版）, W.Richard Stevens 等著

附：客户端测试代码 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
/*  Make the necessary includes and set up the variables.  */

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
    int sockfd;
    int len;
    struct sockaddr_in address;
    int result;
    char ch = 'A';

/*  Create a socket for the client.  */
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

/*  Name the socket, as agreed with the server.  */
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("127.0.0.1");
    address.sin_port = htons(6240);
    len = sizeof(address);

/*  Now connect our socket to the server's socket.  */
    result = connect(sockfd, (struct sockaddr *)&address, len);
    if(result == -1) {
        perror("oops: client3");
        exit(1);
    }

/*  We can now read/write via sockfd.  */
    write(sockfd, &ch, 1);
    read(sockfd, &ch, 1);
    printf("char from server = %c\n", ch);
    close(sockfd);
    exit(0);
}