C/C++编程：web服务器的进程模型

系统管理员 2022-09-13 06:17 11阅读 0赞

作为Web服务器，设计的初衷就是为了能够处理更多的客户端的请求，一般来说，完成冰箱处理请求工作有三种方式可以选择：多进程、多线程、异步方式

# 多进程方式 #

服务器每接收到一个客户端请求，就会由主进程生成一个子进程出来和该请求建立连接进行交互，直到连接断开以后子进程也就结束了。

有点在于各个子进程之间相互独立，各个客户端请求之间相互不受干扰。

缺点在于生成一个子进程需要进行内存复制，在资源和时间上会产生一定的额外开销。如果请求比较多的时候，会对系统资源造成一定的压力。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16]

## accept ##

## 测试accept1 ##

**主进程创建了socket、bind、listen之后，fork()出来多个进程，每个子进程都开始循环处理（accept）这个listen\_fd。每个进程都阻塞在accept上，当一个新的连接到来时候，所有的进程都会被唤醒，但是其中只有一个进程会接受成功，其余皆失败，重新休眠**。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16]

### 服务端 ###

#include<unistd.h>
    #include<stdio.h>
    #include<stdlib.h>
    #include <stdlib.h>
    #include <stdio.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <string.h>
    #include<arpa/inet.h>
    #include <unistd.h>
    #include <errno.h>
    #include	<time.h>
    #define	MAXLINE		4096
    #define	LISTENQ		1024
    int main(int argc, char *argv[])
    {
        
    
        int					listenfd, connfd;
        struct sockaddr_in	servaddr;
    
    
    
        listenfd = socket(AF_INET, SOCK_STREAM, 0);
    
        bzero(&servaddr, sizeof(servaddr));
        servaddr.sin_family      = AF_INET;
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  // 这里指定了IP地址为INADDR_ANY，意思是如果服务器主机有多个网络接口，服务器进程就可以在任意网络上接受客户连接
        servaddr.sin_port        = 8181;
        printf("%d", 8181);
    
        if( bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
        
            printf("bind error, %s", strerror(errno));
            exit(0);
        }
    
        if(listen(listenfd, LISTENQ) < 0){
        
            printf("listen error, %s", strerror(errno));
            exit(0);
        } // 监听listenfd，这样来自客户端的连接就可以在该套接字上由内核接受。 LISTENQ表示内核允许在这个监听描述符上排队的最大客户连接数
    
    
    
        pid_t pid=fork();
        if ( pid < 0 ) {
        
            fprintf(stderr,"错误！");
            exit(0);
        } else if( pid == 0 ) {
        
            while (1){
        
                printf("子进程(%d)空间: %d\n", getpid(), listenfd);
                if((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0){
        
                    printf("accept error, %s", strerror(errno));
                    continue;
                }// 当前服务器进程会在accept上睡眠阻塞，直到某个客户断连接唤醒：TCP连接使用三次握手来建立连接，握手完毕accept返回一个已连接的描述符，我们就可以使用这个描述符与客户端通信了
    
                printf("子进程(%d) accept ok\n ", getpid());
                close(connfd); //关闭connfd： 该调用引发正常的TCP连接终止序列：每个方向上发送一个FIN，每个FIN又由各自的对端确认
            }
            exit(0);
        } else {
        
            pid=fork();
            if ( pid < 0 ) {
        
                fprintf(stderr,"错误！");
                exit(0);
            } else if( pid == 0 ) {
        
                while (1){
        
                    printf("子进程(%d)空间: %d\n", getpid(), listenfd);
                    if((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0){
        
                        printf("accept error, %s", strerror(errno));
                        continue;
                    }// 当前服务器进程会在accept上睡眠阻塞，直到某个客户断连接唤醒：TCP连接使用三次握手来建立连接，握手完毕accept返回一个已连接的描述符，我们就可以使用这个描述符与客户端通信了
    
                    printf("子进程(%d) accept ok\n ", getpid());
                    close(connfd); //关闭connfd： 该调用引发正常的TCP连接终止序列：每个方向上发送一个FIN，每个FIN又由各自的对端确认
                }
            }else{
        
                pid=fork();
                if ( pid < 0 ) {
        
                    fprintf(stderr,"错误！");
                    exit(0);
                } else if( pid == 0 ) {
        
                    while (1){
        
                        printf("子进程(%d)空间: %d\n", getpid(), listenfd);
                        if((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0){
        
                            printf("accept error, %s", strerror(errno));
                            continue;
                        }// 当前服务器进程会在accept上睡眠阻塞，直到某个客户断连接唤醒：TCP连接使用三次握手来建立连接，握手完毕accept返回一个已连接的描述符，我们就可以使用这个描述符与客户端通信了
    
                        printf("子进程(%d) accept ok\n ", getpid());
                        close(connfd); //关闭connfd： 该调用引发正常的TCP连接终止序列：每个方向上发送一个FIN，每个FIN又由各自的对端确认
                    }
                }else{
        
                    while (1){
        
                        printf("父进程(%d)空间: %d\n", getpid(),  listenfd);
                        if((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0){
        
                            printf("accept error, %s", strerror(errno));
                            continue;
                        }// 当前服务器进程会在accept上睡眠阻塞，直到某个客户断连接唤醒：TCP连接使用三次握手来建立连接，握手完毕accept返回一个已连接的描述符，我们就可以使用这个描述符与客户端通信了
    
                        printf("父进程(%d) accept ok\n", getpid() );
                        close(connfd); //关闭connfd： 该调用引发正常的TCP连接终止序列：每个方向上发送一个FIN，每个FIN又由各自的对端确认
                    }
    
    
                }
            }
    
        }
        // 可以使用wait或waitpid函数等待子进程的结束并获取结束状态
        wait();
        getchar();
    }

### 客户端 ###

#include <stdlib.h>
    #include <stdio.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <string.h>
    #include<arpa/inet.h>
    #include <unistd.h>
    #include <errno.h>
    
    #define	MAXLINE		4096
    int main(int argc, char **argv){
        
        int                sockfd, n;
        struct sockaddr_in servaddr;
        char				recvline[MAXLINE + 1];
    
    
    
        // 创建套接字
        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
        
            printf("socket error");
            exit(-1);
        }
    
        // 设置要连接的服务器属性
        bzero(&servaddr, sizeof(servaddr));   // 清零
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = 8181;   // 时间获取服务器的端口都是13
        if (inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr) <= 0){
         // 将argv[1]转换为合适的格式： ipv4/ipv6
            printf("inet_pton error for %s: %s","127.0.0.1", strerror(errno));
            exit(-1);
        }
    
    
        // 使用tcp套接字与指定服务器建立一个tcp连接
        if (connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0){
        
            printf("connect error: %s", strerror(errno));
            exit(-1);
        }
    
    
    
        close(sockfd);
        exit(0);
    }

### 结果分析 ###

先运行服务端，然后不断运行客户端，结果发现每次只会有一个进程能够接收到请求![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_11_color_FFFFFF_t_70_g_se_x_16]  
：当有多个进程fork同一个listenfd监听，这时有一个连接到来—> 最终只会有一个进程能够获取到这个连接 《？？？这是怎么实现的》

### 服务器改进（惊群） ###

#include<stdio.h>
    #include<stdlib.h>
    #include<sys/types.h>
    #include<sys/socket.h>
    #include<sys/wait.h>
    #include<string.h>
    #include<netinet/in.h>
    #include<unistd.h>
    
    #define PROCESS_NUM 10
    int main()
    {
        
        int fd = socket(PF_INET, SOCK_STREAM, 0);
        int connfd;
        int pid;
    
        char sendbuff[1024];
        struct sockaddr_in serveraddr;
        serveraddr.sin_family = AF_INET;
        serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
        serveraddr.sin_port = htons(1234);
        bind(fd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
        listen(fd, 1024);
        int i;
        for(i = 0; i < PROCESS_NUM; ++i){
        
            pid = fork();
            if(pid == 0){
        
                while(1){
        
                    connfd = accept(fd, (struct sockaddr *)NULL, NULL);
                    snprintf(sendbuff, sizeof(sendbuff), "接收到accept事件的进程PID = %d\n", getpid());
    
                    send(connfd, sendbuff, strlen(sendbuff)+1, 0);
                    printf("process %d accept success\n", getpid());
                    close(connfd);
                }
            }
        }
        //int status;
        wait(0);
        return 0;
    }

## 效果追踪分析 ##

效果：  
![在这里插入图片描述][e07dd9d4a8fe4f7e81120f5efac7409f.png]  
这个程序模拟上面的场景，当我们用telnet连接该服务器程序时，会看到只返回一个进程pid，即只有一个进程被唤醒。

我们用strace -f来追踪fork子进程的执行：

编译：cc fork\_thunder\_herd.c -o server

一个终端执行strace -f ./server 你会看到如下结果（只截取部分可以说明问题的截图，减小篇幅）：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
这里我们首先看到系统创建了十个进程。下面这张图你会看出十个进程阻塞在accept这个系统调用上面：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
接下来在另一个终端执行telnet 127.0.0.1 1234：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
很明显当telnet连接的时候只有一个进程accept成功,你会不会和我有同样的疑问，就是会不会内核中唤醒了所有的进程只是没有获取到资源失败了，就好像惊群被“隐藏”？

这个问题很好证明，我们修改一下代码：

connfd = accept(fd, (struct sockaddr *)NULL, NULL);
                    if(connfd == 0){
        
     
                        snprintf(sendbuff, sizeof(sendbuff), "接收到accept事件的进程PID = %d\n", getpid());
     
                        send(connfd, sendbuff, strlen(sendbuff)+1, 0);
                        printf("process %d accept success\n", getpid());
                        close(connfd);
                    }else{
        
                        printf("process %d accept a connection failed: %s\n", getpid(), strerror(errno));
                        close(connfd);
                    }

没错，就是增加了一个accept失败的返回信息，按照上面的步骤运行，这里我就不截图了，我只告诉你运行结果与上面的运行结果无异，增加的失败信息并没有输出，也就说明了这里并没有发生惊群，所以注意阻塞和惊群的唤醒的区别。

Google了一下：其实在linux2.6版本以后，linux内核已经解决了accept（）函数的“惊群”现象，大概的处理方式就是，当内核接收到一个客户连接后，只会唤醒等待队列上的第一个进程（线程）,所以如果服务器采用accept阻塞调用方式，在最新的linux系统中已经没有“惊群效应”了

# 多线程方式 #

多线程方式和多进程方式很相似，服务器每接收一个客户端请求时，会产生一个线程与该客户端进行交互。而产生一个线程的开销比进程小很多，所以多线程的方式在一定程度上减轻了web服务器对系统资源的要求。缺点是多线程之间存在内存共享、彼此间存在相互影响的情况。

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16 1]

# 异步方式 #

*  [惊群效应][Link 1]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/25c6c983d1194c0b814c34ac26d53aa9.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/8481ed02afc0405f807d56a36615ca7f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_11_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/6a675f9171b54f6e937bdcf8f951e303.png
[e07dd9d4a8fe4f7e81120f5efac7409f.png]: /images/20220828/deca2745e92a49eb958181ba36472580.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/50aa0f7921964828b56bac99554d72fe.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/3ac272e127614b9a930cbec08428bd92.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/956f3ce5672c4798a10aa44f3ce11d68.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAT2NlYW4mJlN0YXI_size_18_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/861c495fa1e34d3aa88d333b0d13394a.png
[Link 1]: https://blog.csdn.net/lyztyycode/article/details/78648798