网络IO比较透彻了

C1000k百万连接

weibo用户上千万

什么因素限制了C1000K问题的解决

1,操作系统能否支持百万连接

2,操作系统维持百万连接需要多少内存

3,应用程序维持百万连接需要多少内存

4,百万连接的吞吐量是否超过了网络限制

=====================================================

1,操作系统是否支持百万连接

操作系统包含最大打开文件数限制,分为系统全局的,和进程级的限制

a,全局限制

在linux下执行:cat /proc/sys/fs/file-nr        得到 1344    0       785709

第三个数字785709就是当前系统的全局最大打开文件数

为了修改这个数值,用root权限修改/etc/sysctl.conf 文件

fs.file-max = 1020000
net.ipv4.ip_conntrack_max = 1020000
net.ipv4.netfilter.ip_conntrack_max = 1020000

需要重启系统服务生效

#Linux :  sudo sysctl -p /etc/sysctl.conf

#BSD :   /etc/rc.d/sysctl reload

b,进程限制

执行 ulimit -u  得到  4096

说明当前 Linux 系统的每一个进程只能最多打开 1024 个文件

b1:临时修改   ulimit -n 1020000

b2:永久修改  编辑 /etc/security/limits.conf 文件, 加入如下行:

# /etc/security/limits.conf
work         hard    nofile      1020000
work         soft    nofile      1020000

第一列的 work 表示 work 用户, 你可以填 *, 或者 root. 然后保存退出, 重新登录服务器.

注意:linux内核源码中有一个常量(NR_OPEN in /usr/include/linux/fs.h),限制了最大打开文件数, 如 RHEL 5 是 1048576(2^20), 所以, 要想支持 C1000K, 你可能还需要重新编译内核.

 

2,操作系统维持百万连接需要多少内存

对于 Linux 操作系统, socket(fd) 是一个整数, 所以, 猜想操作系统管理一百万个连接所占用的内存应该是 4M/8M, 再包括一些管理信息, 应该会是 100M 左右. 不过, 还有 socket 发送和接收缓冲区所占用的内存没有分析. 为此, 我写了最原始的 C 网络程序来验证:

服务器:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>
#include <sys/select.h>

#define MAX_PORTS 10

int main(int argc, char **argv){
    struct sockaddr_in addr;
    const char *ip = "0.0.0.0";
    int opt = 1;
    int bufsize;
    socklen_t optlen;
    int connections = 0;
    int base_port = 7000;
    if(argc > 2){
        base_port = atoi(argv[1]);
    }

    int server_socks[MAX_PORTS];

    for(int i=0; i<MAX_PORTS; i++){
        int port = base_port + i;
        bzero(&addr, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons((short)port);
        inet_pton(AF_INET, ip, &addr.sin_addr);

        int serv_sock;
        if((serv_sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){
            goto sock_err;
        }
        if(setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1){
            goto sock_err;
        }
        if(bind(serv_sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){
            goto sock_err;
        }
        if(listen(serv_sock, 1024) == -1){
            goto sock_err;
        }

        server_socks[i] = serv_sock;
        printf("server listen on port: %d\n", port);
    }

    //optlen = sizeof(bufsize);
    //getsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, &optlen);
    //printf("default send/recv buf size: %d\n", bufsize);

    while(1){
        fd_set readset;
        FD_ZERO(&readset);
        int maxfd = 0;
        for(int i=0; i<MAX_PORTS; i++){
            FD_SET(server_socks[i], &readset);
            if(server_socks[i] > maxfd){
                maxfd = server_socks[i];
            }
        }
        int ret = select(maxfd + 1, &readset, NULL, NULL, NULL);
        if(ret < 0){
            if(errno == EINTR){
                continue;
            }else{
                printf("select error! %s\n", strerror(errno));
                exit(0);
            }
        }

        if(ret > 0){
            for(int i=0; i<MAX_PORTS; i++){
                if(!FD_ISSET(server_socks[i], &readset)){
                    continue;
                }
                socklen_t addrlen = sizeof(addr);
                int sock = accept(server_socks[i], (struct sockaddr *)&addr, &addrlen);
                if(sock == -1){
                    goto sock_err;
                }
                connections ++;
                printf("connections: %d, fd: %d\n", connections, sock);
            }
        }
    }

    return 0;
sock_err:
    printf("error: %s\n", strerror(errno));
    return 0;
}

注意, 服务器监听了 10 个端口, 这是为了测试方便. 因为只有一台客户端测试机, 最多只能跟同一个 IP 端口创建 30000 多个连接, 所以服务器监听了 10 个端口, 这样一台测试机就可以和服务器之间创建 30 万个连接了.

2,客户端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/tcp.h>

int main(int argc, char **argv){
    if(argc <=  2){
        printf("Usage: %s ip port\n", argv[0]);
        exit(0);
    }

    struct sockaddr_in addr;
    const char *ip = argv[1];
    int base_port = atoi(argv[2]);
    int opt = 1;
    int bufsize;
    socklen_t optlen;
    int connections = 0;

    bzero(&addr, sizeof(addr));
    addr.sin_family = AF_INET;
    inet_pton(AF_INET, ip, &addr.sin_addr);

    char tmp_data[10];
    int index = 0;
    while(1){
        if(++index >= 10){
            index = 0;
        }
        int port = base_port + index;
        printf("connect to %s:%d\n", ip, port);

        addr.sin_port = htons((short)port);

        int sock;
        if((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1){
            goto sock_err;
        }
        if(connect(sock, (struct sockaddr *)&addr, sizeof(addr)) == -1){
            goto sock_err;
        }

        connections ++;
        printf("connections: %d, fd: %d\n", connections, sock);

        if(connections % 10000 == 9999){
            printf("press Enter to continue: ");
            getchar();
        }
        usleep(1 * 1000);
        /*
           bufsize = 5000;
           setsockopt(serv_sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize));
           setsockopt(serv_sock, SOL_SOCKET, SO_RCVBUF, &bufsize, sizeof(bufsize));
         */
    }

    return 0;
sock_err:
    printf("error: %s\n", strerror(errno));
    return 0;
}

我测试 10 万个连接, 这些连接是空闲的, 什么数据也不发送也不接收. 这时, 进程只占用了不到 1MB 的内存. 但是, 通过程序退出前后的 free 命令对比, 发现操作系统用了 200M(大致)内存来维护这 10 万个连接! 如果是百万连接的话, 操作系统本身就要占用 2GB 的内存! 也即 2KB 每连接.

可以修改

/proc/sys/net/ipv4/tcp_wmem

/proc/sys/net/ipv4/tcp_rmem

来控制TCP连接的发送和接收缓冲的大小

3.应用程序维持百万连接需要多少内存

通过上面的测试代码, 可以发现, 应用程序维持百万个空闲的连接, 只会占用操作系统的内存, 通过 ps 命令查看可知, 应用程序本身几乎不占用内存.

4,百万连接的吞吐量是否超过了网络限制

假设百万连接中有20%是活跃的,每个连接每秒传输1KB 的数据, 那么需要的网络带宽是 0.2M x 1KB/s x 8 = 1.6Gbps, 要求服务器至少是万兆网卡(10Gbps).

总结

 

 

Linux 系统需要修改内核参数和系统配置, 才能支持 C1000K. C1000K 的应用要求服务器至少需要 2GB 内存, 如果应用本身还需要内存, 这个要求应该是至少 10GB 内存. 同时, 网卡应该至少是万兆网卡.

 

 

 

当然, 这仅仅是理论分析, 实际的应用需要更多的内存和 CPU 资源来处理业务数据.

测试工具

测试操作系统最大连接数的工具: https://github.com/ideawu/c1000k

 

 

======================================================================

字节,字符及占用内存大小情况

(一)“字节”的定义

字节(Byte)是一种计量单位,表示数据量多少,它是计算机信息技术用于计量存储容量的一种计量单位。

 

(二)“字符”的定义

字符是指计算机中使用的文字和符号,比如1、2、3、A、B、C、~!·#¥%……—*()——+、等等。

 

(三)“字节”与“字符”

它们完全不是一个位面的概念,所以两者之间没有“区别”这个说法。不同编码里,字符和字节的对应关系不同:

ASCII码中,一个英文字母(不分大小写)占一个字节的空间,一个中文汉字占两个字节的空间。一个二进制数字序列,在计算机中作为一个数字单元,一般为8位二进制数,换算为十进制。最小值0,最大值255。

UTF-8编码中,一个英文字符等于一个字节,一个中文(含繁体)等于三个字节。

Unicode编码中,一个英文等于两个字节,一个中文(含繁体)等于两个字节。

符号:英文标点占一个字节,中文标点占两个字节。举例:英文句号“.”占1个字节的大小,中文句号“。”占2个字节的大小。

UTF-16编码中,一个英文字母字符或一个汉字字符存储都需要2个字节(Unicode扩展区的一些汉字存储需要4个字节)。

UTF-32编码中,世界上任何字符的存储都需要4个字节。

 

 

字节 (byte):8个二进制位为一个字节(B),最常用的单位。计算机存储单位一般用B,KB,MB,GB,TB,PB,EB,ZB,YB,BB来表示,它们之间的关系是:
  1B(Byte字节)=8bit
  1KB (Kilobyte 千字节)=1024B,
  1MB (Mega byte 兆字节 简称“兆”)=1024KB,
  1GB (Giga byte 吉字节 又称“千兆”)=1024MB,
  1TB (Tera byte 万亿字节 太字节)=1024GB,其中1024=2^10 ( 2 的10次方)

用一个txt文档做实验
1000个汉字---utf-8编码格式---占用2.95k,接近3k。这是因为utf-8编码格式下1000个字符占3000字节,相当于3000B,接近3k。
---asci编码格式下,2k
---unicode编码格式下,2k

 

======================================================================

Linux下TCP最大连接数受限问题

 

一、 文件数限制修改
1、用户级别
查看Linux系统用户最大打开文件限制:
# ulimit -n
1024

(1) vi /etc/security/limits.conf
mysql soft nofile 10240
mysql hard nofile 10240
其中mysql指定了要修改哪个用户的打开文件数限制。
可用'*'号表示修改所有用户的限制;soft或hard指定要修改软限制还是硬限制;10240则指定了想要修改的新的限制值,即最大打开文件数(请注意软限制值要小于或等于硬限制)。

(2) vi /etc/pam.d/login
session required /lib/security/pam_limits.so
这是告诉Linux在用户完成系统登录后,应该调用pam_limits.so模块来设置系统对该用户可使用的各种资源数量的最大限制(包括用户可打开的最大文件数限制)。
而pam_limits.so模块就会从/etc/security/limits.conf文件中读取配置来设置这些限制值。

2、Linux系统级别
查看Linux系统对同时打开文件数的硬限制:
# sysctl -a|grep file-max
fs.file-max = 65535
这表明这台Linux系统最多允许同时打开(即包含所有用户打开文件数总和)65535个文件,是Linux系统级硬限制,所有用户级的打开文件数限制都不会超过这个数值。
通常这个系统级硬限制是Linux系统在启动时根据系统硬件资源状况计算出来的最佳的最大同时打开文件数限制。

(1) vi /etc/sysctl.conf
fs.file-max = 1000000
立即生效:
# sysctl -p

二、 网络端口限制修改
查看Linux系统最大追踪TCP连接数量:
# sysctl -a | grep ipv4.ip_conntrack_max
net.ipv4.ip_conntrack_max = 20000
这表明系统将对最大跟踪的TCP连接数限制默认为20000。

查看Linux系统端口范围:
# sysctl -a | grep ipv4.ip_local_port_range
net.ipv4.ip_local_port_range = 1024 30000
注意:
每个TCP客户端连接都要占用一个唯一的本地端口号(此端口号在系统的本地端口号范围限制中),如果现有的TCP客户端连接已将所有的本地端口号占满。将不能创建新的TCP连接。

(1) vi /etc/sysctl.conf
net.ipv4.ip_local_port_range = 1024    65535
net.ipv4.ip_conntrack_max = 20000
如果按上述端口范围进行设置,则理论上单独一个进程最多可以同时建立60000多个TCP客户端连接。
如果按上述参数进行设置,则理论上单独一个进程最多可以同时建立20000多个TCP客户端连接。


备注:

 


对mysql用户可同时打开文件数设置为10240个;
将Linux系统可同时打开文件数设置为1000000个(一定要大于对用户的同时打开文件数限制);
将Linux系统对最大追踪的TCP连接数限制为20000个(但是,建议设置为10240;因为对mysql用户的同时打开文件数已经限制在10240个;且较小的值可以节省内存);
将linux系统端口范围配置为1024~30000(可以支持60000个以上连接,不建议修改;默认已经支持20000个以上连接);

综合上述四点,TCP连接数限制在10140个。
这10240个文件中还得除去每个进程必然打开的标准输入,标准输出,标准错误,服务器监听 socket,进程间通讯的unix域socket等文件。

 


 

因此,当需要对TCP连接数进行调整时只需要调整ulimit参数。

 

Linux下查看tcp连接数及状态命令:

netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a, S[a]}'

==================================================================================================================================================================================

高性能网络编程(一):单台服务器并发TCP连接数到底可以有多少

 

前言


曾几何时我们还在寻求网络编程中C10K问题(有关C10K问题请见文章《The C10K problem(英文在线阅读英文PDF版下载中文译文)》)的解决方案,但是现在从硬件和操作系统支持来看单台服务器支持上万并发连接已经没有多少挑战性了。

我们先假设单台服务器最多只能支持万级并发连接,其实对绝大多数应用来说已经远远足够了,但是对于一些拥有很大用户基数的互联网公司,往往面临的并发连接数是百万、千万、甚至腾讯的上亿(注:QQ默认用的UDP协议,具体请见讨论贴《为什么QQ用的是UDP协议而不是TCP协议?》)。

虽然现在的集群,分布式技术可以为我们将并发负载分担在多台服务器上,那我们只需要扩展出数十台电脑就可以解决问题,但是我们更希望能更大的挖掘单台服务器的资源,先努力垂直扩展,再进行水平扩展,这样可以有效的节省服务器相关的开支(硬件资源、机房、运维人力、电力其实也是一笔不小的开支)。

那么到底一台服务器能够支持多少TCP并发连接呢?这就是本文要讨论的问题。

C10K问题系列文章


本文是C10K问题系列文章中的第1篇,总目录如下:
 

常识一:文件句柄限制


在linux下编写网络服务器程序的朋友肯定都知道每一个tcp连接都要占一个文件描述符,一旦这个文件描述符使用完了,新的连接到来返回给我们的错误是“Socket/File:Can't open so many files”。

这时你需要明白操作系统对可以打开的最大文件数的限制。
 

1进程限制


执行 ulimit -n 输出 1024,说明对于一个进程而言最多只能打开1024个文件,所以你要采用此默认配置最多也就可以并发上千个TCP连接。临时修改:ulimit -n 1000000,但是这种临时修改只对当前登录用户目前的使用环境有效,系统重启或用户退出后就会失效。

重启后失效的修改(不过我在CentOS 6.5下测试,重启后未发现失效),编辑 /etc/security/limits.conf 文件, 修改后内容为:
 
  • soft nofile 1000000
  • hard nofile 1000000

永久修改:编辑/etc/rc.local,在其后添加如下内容:
 
  • ulimit -SHn 1000000
 

2全局限制


执行 cat /proc/sys/fs/file-nr 输出 9344 0 592026,分别为:
 
  • 1. 已经分配的文件句柄数,
  • 2. 已经分配但没有使用的文件句柄数,
  • 3. 最大文件句柄数。

但在kernel 2.6版本中第二项的值总为0,这并不是一个错误,它实际上意味着已经分配的文件描述符无一浪费的都已经被使用了 。

我们可以把这个数值改大些,用 root 权限修改 /etc/sysctl.conf 文件:
 
  • fs.file-max = 1000000
  • net.ipv4.ip_conntrack_max = 1000000
  • net.ipv4.netfilter.ip_conntrack_max = 1000000
 

常识二:端口号范围限制?


操作系统上端口号1024以下是系统保留的,从1024-65535是用户使用的。由于每个TCP连接都要占一个端口号,所以我们最多可以有60000多个并发连接。我想有这种错误思路朋友不在少数吧?(其中我过去就一直这么认为)

我们来分析一下吧。

如何标识一个TCP连接:
系统用一个4四元组来唯一标识一个TCP连接:{local ip, local port,remote ip,remote port}。好吧,我们拿出《UNIX网络编程:卷一》第四章中对accept的讲解来看看概念性的东西,第二个参数cliaddr代表了客户端的ip地址和端口号。而我们作为服务端实际只使用了bind时这一个端口,说明端口号65535并不是并发量的限制。

server最大tcp连接数:
server通常固定在某个本地端口上监听,等待client的连接请求。不考虑地址重用(unix的SO_REUSEADDR选项)的情况下,即使server端有多个ip,本地监听端口也是独占的,因此server端tcp连接4元组中只有remote ip(也就是client ip)和remote port(客户端port)是可变的,因此最大tcp连接为客户端ip数×客户端port数,对IPV4,不考虑ip地址分类等因素,最大tcp连接数约为2的32次方(ip数)×2的16次方(port数),也就是server端单机最大tcp连接数约为2的48次方。

本文小结


上面给出的结论都是理论上的单机TCP并发连接数,实际上单机并发连接数肯定要受硬件资源(内存)、网络资源(带宽)的限制,至少对我们的需求现在可以做到数十万级的并发了,你的呢?

==================================================================================================================================================================================

==================================================================================================================================================================================

高性能网络编程(六):一文读懂高性能网络编程中的线程模型

 

1、前言


本文接上篇《高性能网络编程(五):一文读懂高性能网络编程中的I/O模型》。

随着互联网的发展,面对海量用户高并发业务,传统的阻塞式的服务端架构模式已经无能为力。本文(和上篇《高性能网络编程(五):一文读懂高性能网络编程中的I/O模型》)旨在为大家提供有用的高性能网络编程的I/O模型概览以及网络服务进程模型的比较,以揭开设计和实现高性能网络架构的神秘面纱。

另外,作者的另一篇《新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析》,也值得一读,推荐一并阅读之。

3、C10K问题系列文章


本文是C10K问题系列文章中的第6篇,总目录如下:
   

4、线程模型


上篇《高性能网络编程(五):一文读懂高性能网络编程中的I/O模型》介绍完服务器如何基于 I/O 模型管理连接,获取输入数据,下面将介绍基于进程/线程模型,服务器如何处理请求。

值得说明的是,具体选择线程还是进程,更多是与平台及编程语言相关。

例如 C 语言使用线程和进程都可以(例如 Nginx 使用进程,Memcached 使用线程),Java 语言一般使用线程(例如 Netty),为了描述方便,下面都使用线程来进行描述。

5、线程模型1:传统阻塞 I/O 服务模型


高性能网络编程(六):一文读懂高性能网络编程中的线程模型_1.jpeg

 

 

 

 

 

 

 

 

特点:

  • 1)采用阻塞式 I/O 模型获取输入数据;
  • 2)每个连接都需要独立的线程完成数据输入,业务处理,数据返回的完整操作。

存在问题:
 
  • 1)当并发数较大时,需要创建大量线程来处理连接,系统资源占用较大;
  • 2)连接建立后,如果当前线程暂时没有数据可读,则线程就阻塞在 Read 操作上,造成线程资源浪费。
 

6、线程模型2:Reactor 模式

 

6.1基本介绍


针对传统阻塞 I/O 服务模型的 2 个缺点,比较常见的有如下解决方案:
 
  • 1)基于 I/O 复用模型:多个连接共用一个阻塞对象,应用程序只需要在一个阻塞对象上等待,无需阻塞等待所有连接。当某条连接有新的数据可以处理时,操作系统通知应用程序,线程从阻塞状态返回,开始进行业务处理;
  • 2)基于线程池复用线程资源:不必再为每个连接创建线程,将连接完成后的业务处理任务分配给线程进行处理,一个线程可以处理多个连接的业务。


I/O 复用结合线程池,这就是 Reactor 模式基本设计思想,如下图:
高性能网络编程(六):一文读懂高性能网络编程中的线程模型_2.jpeg
 

 

 

 

 

 

 

 

Reactor 模式,是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。

服务端程序处理传入多路请求,并将它们同步分派给请求对应的处理线程,Reactor 模式也叫     Dispatcher(调度)     模式。

即 I/O 多了复用统一监听事件,收到事件后分发(Dispatch 给某进程),是编写高性能网络服务器的必备技术之一。

Reactor 模式中有 2 个关键组成:

  • 1)Reactor:Reactor 在一个单独的线程中运行,负责监听和分发事件,分发给适当的处理程序来对 IO 事件做出反应。 它就像公司的电话接线员,它接听来自客户的电话并将线路转移到适当的联系人;
  • 2)Handlers:处理程序执行 I/O 事件要完成的实际事件,类似于客户想要与之交谈的公司中的实际官员。Reactor 通过调度适当的处理程序来响应 I/O 事件,处理程序执行非阻塞操作。

根据 Reactor 的数量和处理资源池线程的数量不同,有 3 种典型的实现:
 
  • 1)单 Reactor 单线程;

  • 2)单 Reactor 多线程;

  • 3)主从 Reactor 多线程。


下面详细介绍这 3 种实现方式。
 

6.2单 Reactor 单线程


高性能网络编程(六):一文读懂高性能网络编程中的线程模型_3.jpeg
 

 

 

 

 

 

 

 

其中,Select 是前面 I/O 复用模型介绍的标准网络编程 API,可以实现应用程序通过一个阻塞对象监听多路连接请求,其他方案示意图类似。

方案说明:

  • 1)Reactor 对象通过 Select 监控客户端请求事件,收到事件后通过 Dispatch 进行分发;
  • 2)如果是建立连接请求事件,则由 Acceptor 通过 Accept 处理连接请求,然后创建一个 Handler 对象处理连接完成后的后续业务处理;
  • 3)如果不是建立连接事件,则 Reactor 会分发调用连接对应的 Handler 来响应;
  • 4)Handler 会完成 Read→业务处理→Send 的完整业务流程。


优点:模型简单,没有多线程、进程通信、竞争的问题,全部都在一个线程中完成。
缺点:性能问题,只有一个线程,无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时,整个进程无法处理其他连接事件,很容易导致性能瓶颈。

可靠性问题,线程意外跑飞,或者进入死循环,会导致整个系统通信模块不可用,不能接收和处理外部消息,造成节点故障。

 

 

使用场景:客户端的数量有限,业务处理非常快速,比如 Redis,业务处理的时间复杂度 O(1)。

 

 

 

 

 

 

 

 

 

 

6.3单 Reactor 多线程


高性能网络编程(六):一文读懂高性能网络编程中的线程模型_4.jpeg

 

 

 

 

 

 

方案说明:

  • 1)Reactor 对象通过 Select 监控客户端请求事件,收到事件后通过 Dispatch 进行分发;
  • 2)如果是建立连接请求事件,则由 Acceptor 通过 Accept 处理连接请求,然后创建一个 Handler 对象处理连接完成后续的各种事件;

  • 3)如果不是建立连接事件,则 Reactor 会分发调用连接对应的 Handler 来响应;
  • 4)Handler 只负责响应事件,不做具体业务处理,通过 Read 读取数据后,会分发给后面的 Worker 线程池进行业务处理;
  • 5)Worker 线程池会分配独立的线程完成真正的业务处理,如何将响应结果发给 Handler 进行处理;
  • 6)Handler 收到响应结果后通过 Send 将响应结果返回给 Client。


优点:可以充分利用多核 CPU 的处理能力。
缺点:多线程数据共享和访问比较复杂;Reactor 承担所有事件的监听和响应,在单线程中运行,高并发场景下容易成为性能瓶颈。
 

 

 

 

 

 

 

 

 

 

 

 

 

 

6.4主从 Reactor 多线程


高性能网络编程(六):一文读懂高性能网络编程中的线程模型_5.jpeg

针对单 Reactor 多线程模型中,Reactor 在单线程中运行,高并发场景下容易成为性能瓶颈,可以让 Reactor 在多线程中运行。

方案说明:
 
  • 1)Reactor 主线程 MainReactor 对象通过 Select 监控建立连接事件,收到事件后通过 Acceptor 接收,处理建立连接事件;
  • 2)Acceptor 处理建立连接事件后,MainReactor 将连接分配 Reactor 子线程给 SubReactor 进行处理;
  •  
  •  
  • 3)SubReactor 将连接加入连接队列进行监听,并创建一个 Handler 用于处理各种连接事件;

  •  
  •  
  • 4)当有新的事件发生时,SubReactor 会调用连接对应的 Handler 进行响应;
  • 5)Handler 通过 Read 读取数据后,会分发给后面的 Worker 线程池进行业务处理;
  • 6)Worker 线程池会分配独立的线程完成真正的业务处理,如何将响应结果发给 Handler 进行处理;
  • 7)Handler 收到响应结果后通过 Send 将响应结果返回给 Client。


优点:父线程与子线程的数据交互简单职责明确,父线程只需要接收新连接,子线程完成后续的业务处理。

父线程与子线程的数据交互简单,Reactor 主线程只需要把新连接传给子线程,子线程无需返回数据。

这种模型在许多项目中广泛使用,包括 Nginx 主从 Reactor 多进程模型,Memcached 主从多线程,Netty 主从多线程模型的支持。

 

 

6.5小结


3 种模式可以用个比喻来理解:(餐厅常常雇佣接待员负责迎接顾客,当顾客入坐后,侍应生专门为这张桌子服务)
 
  • 1)单 Reactor 单线程,接待员和侍应生是同一个人,全程为顾客服务;
  • 2)单 Reactor 多线程,1 个接待员,多个侍应生,接待员只负责接待;
  • 3)主从 Reactor 多线程,多个接待员,多个侍应生。

Reactor 模式具有如下的优点:
 
  • 1)响应快,不必为单个同步时间所阻塞,虽然 Reactor 本身依然是同步的;
  • 2)编程相对简单,可以最大程度的避免复杂的多线程及同步问题,并且避免了多线程/进程的切换开销;
  • 3)可扩展性,可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源;
  • 4)可复用性,Reactor 模型本身与具体事件处理逻辑无关,具有很高的复用性。
 

7、线程模型2:Proactor 模型


在 Reactor 模式中,Reactor 等待某个事件或者可应用或者操作的状态发生(比如文件描述符可读写,或者是 Socket 可读写)。

然后把这个事件传给事先注册的 Handler(事件处理函数或者回调函数),由后者来做实际的读写操作。

其中的读写操作都需要应用程序同步操作,所以 Reactor 是非阻塞同步网络模型。

如果把 I/O 操作改为异步,即交给操作系统来完成就能进一步提升性能,这就是异步网络模型 Proactor。

高性能网络编程(六):一文读懂高性能网络编程中的线程模型_1.jpeg

Proactor 是和异步 I/O 相关的,详细方案如下:
 
  • 1)Proactor Initiator 创建 Proactor 和 Handler 对象,并将 Proactor 和 Handler 都通过 AsyOptProcessor(Asynchronous Operation Processor)注册到内核;
  • 2)AsyOptProcessor 处理注册请求,并处理 I/O 操作;
  • 3)AsyOptProcessor 完成 I/O 操作后通知 Proactor;
  • 4)Proactor 根据不同的事件类型回调不同的 Handler 进行业务处理;
  • 5)Handler 完成业务处理。

可以看出 Proactor 和 Reactor 的区别:
 
  • 1)Reactor 是在事件发生时就通知事先注册的事件(读写在应用程序线程中处理完成);
  • 2)Proactor 是在事件发生时基于异步 I/O 完成读写操作(由内核完成),待 I/O 操作完成后才回调应用程序的处理器来进行业务处理。

理论上 Proactor 比 Reactor 效率更高,异步 I/O 更加充分发挥 DMA(Direct Memory Access,直接内存存取)的优势。

但是Proactor有如下缺点:
 
  • 1)编程复杂性,由于异步操作流程的事件的初始化和事件完成在时间和空间上都是相互分离的,因此开发异步应用程序更加复杂。应用程序还可能因为反向的流控而变得更加难以 Debug;
  • 2)内存使用,缓冲区在读或写操作的时间段内必须保持住,可能造成持续的不确定性,并且每个并发操作都要求有独立的缓存,相比 Reactor 模式,在 Socket 已经准备好读或写前,是不要求开辟缓存的;
  • 3)操作系统支持,Windows 下通过 IOCP 实现了真正的异步 I/O,而在 Linux 系统下,Linux 2.6 才引入,目前异步 I/O 还不完善。

因此在 Linux 下实现高并发网络编程都是以 Reactor 模型为主。
发布了133 篇原创文章 · 获赞 63 · 访问量 27万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览