高并发下的网络 IO 模型设计

从IO多路复用到Reactor模式:手写网络库核心与高并发落地 高并发服务端编程中,IO多路复用与事件驱动是绕不开的基础。传统的BIO模型每个连接占用一个线程,连接数上万后线程开销与上下文切换会拖垮系统。epoll等IO多路复用机制解决了内核高效感知就绪事件的问题,但事件到达后如何分发和处理,仍需一套清晰的设计范式。Reactor模式正是建立在IO多路复用之上的事件驱动架构,它通过事件循环、事件分发器和处理器抽象,让少量线程即可管理海量连接。从单线程Reactor到主从Reactor,再到与业务线程池结合的混合模型,这种思想贯穿Netty、Redis、libevent等 阅读详情

今天我们先聊一下高并发下的网络 IO 模型设计

高并发即我们所说的 C10K(一个server 服务 1w 个 client),C10M,写出高并发的程序相信是每个后端程序员的追求,高并发架构其实有一些很通用的架构设计,如无锁化,缓存等,今天我们主要研究下高并发下的网络 IO 模型设计,我们知道不管是 Nginx,还是 Redis,Kafka,RocketMQ 等中间件,都能轻松支持非常高的 QPS,其实它们背后的网络 IO 模型设计理念都是一致的,所以了解这一块对我们了解设计出高并发的网络 IO 框架具体重要意义,本文将会从以下几个方面来循序渐近地向大家介绍如何设计出一个高并发的网络 IO 框架

  • 传统网络 IO 模型的缺陷

  • 针对传统网络 IO 模型缺陷的改进

  • 多线程/多进程

  • 阻塞改为非阻塞

  • IO 多路复用

  • Reactor 的几种模型介绍

传统网络 IO 模型的缺陷

我们首先来看下传统网络 IO 模型有哪些缺陷,主要看它们的阻塞点有哪些。我们用一张图来看下客户端和服务端的基于 TCP 的通信流程

​服务端的伪代码如下

listenSocket = socket(); //调用socket系统调用创建一个主动套接字
bind(listenSocket);  //绑定地址和端口
listen(listenSocket); //将默认的主动套接字转换为服务器使用的被动套接字,也就是监听套接字
while (1) { //循环监听是否有客户端连接请求到来
   connSocket = accept(listenSocket); //接受客户端连接
   recv(connsocket); //从客户端读取数据,只能同时处理一个客户端
   send(connsocket); //给客户端返回数据,只能同时处理一个客户端
}

可以看到,主要的通信流程如下

  1. server 创建监听 socket 后,执行 bind() 绑定 IP 和端口,然后调用 listen() 监听,代表 server 已经准备好接收请求了,listen 的主要作用其实是初始化半连接和全连接队列大小

  2. server 准备好后,client 也创建 socket ,然后执行 connect 向 server 发起连接请求,这一步会被阻塞,需要等待三次握手完成,第一次握手完成,服务端会创建 socket(这个 socket 是连接 socket,注意不要和第一步的监听 socket 搞混了),将其放入半连接队列中,第三次握手完成,系统会把 socket 从半连接队列摘下放入全连接队列中,然后 accept 会将其从全连接队列中摘下,之后此 socket 就可以与客户端 socket 正常通信了,默认情况下如果全连接队列里没有 socket,则 accept 会阻塞等待三次握手完成

经过三次握手后 client 和 server 就可以基于 socket 进行正常的进程通信了(即调用 write 发送写请求,调用 read 执行读请求),但需要注意的是 read,write 也很可能会被阻塞,需要满足一定的条件读写才会成功返回,在 LInux 中一切皆文件,socket 也不例外,每个打开的文件都有读写缓冲区,如下图所示

​对文件执行 read(),write() 的具体流程如下

  1. 当执行 read() 时,会从内核读缓冲区中读取数据,如果缓冲区中没有数据,则会阻塞等待,等数据到达后,会通过 DMA 拷贝将数据拷贝到内核读缓冲区中,然后会唤醒用户线程将数据从内核读缓冲区拷贝到应用缓冲区中

  2. 当执行 write() 时,会将数据从应用缓冲区拷贝到内核写缓冲区,然后再通过 DMA 拷贝将数据从写缓冲区发送到设备上传输出去,如果写缓冲区满,则 write 会阻塞等待写缓冲区可写

经过以上分析,我们可以看到传统的 socket 通信会阻塞在 connect,accept,read/write 这几个操作上,这样的话如果 server 是单进程/线程的话,只要 server 阻塞,就不能再接收其他 client 的处理了,由此可知传统的 socket 无法支持 C10K

针对传统网络 IO 模型缺陷的改进

接下来我们来看看针对传统 IO 模型缺陷的改进,主要有两种

  1. 多进程/线程模型

  2. IO 多路程复用

多进程/线程模型

如果 server 是单进程,阻塞显然会导致 server 无法再处理其他 client 请求了,那我们试试把 server 改成多进程的?只要父进程 accept 了 socket ,就 fork 一个子进程,把这个 socket 交给子进程处理,这样就算子进程阻塞了,也不影响父进程继续监听和其他子进程处理连接

​程序伪代码如下

while(1) {
  connfd = accept(listenfd);  // 阻塞建立连接
  // fork 创建一个新进程
  if (fork() == 0) {
    // accept 后子进程开始工作
    doWork(connfd);
  }
}
void doWork(connfd) {
  int n = read(connfd, buf);  // 阻塞读数据
  doSomeThing(buf);  // 利用读到的数据做些什么
  close(connfd);     // 关闭连接,循环等待下一个连接
}

通过这种方式确实解决了单进程 server 阻塞无法处理其他 client 请求的问题,但众所周知 fork 创建子进程是非常耗时的,包括页表的复制,进程切换时页表的切换等都非常耗时,每来一个请求就创建一个进程显然是无法接受的

为了节省进程创建的开销,于是有人提出把多进程改成多线程,创建线程(使用 pthread_create)的开销确实小了很多,但同样的,线程与进程一样,都需要占用堆栈等资源,而且碰到阻塞,唤醒等都涉及到用户态,内核态的切换,这些都极大地消耗了性能

由此可知采用多进程/线程的方式并不可取

画外音: 在 Linux 下进程和线程都是用统一的 task_struct 表示,区别不大,所以下文描述不管是进程还是线程区别都不大

【文章福利】另外小编还整理了一些C/C++后台开发教学视频,相关面试题,后台学习路线图免费分享,需要的可以自行添加:Q群:720209036 点击加入~ 群文件共享

小编强力推荐C++后台开发免费学习地址:C/C++Linux服务器开发高级架构师/C++后台开发架构师​

​阻塞改为非阻塞

既然多进程/多线程的方式并不可取,那能否将进程的阻塞操作(connect,accept,read/write)改为非阻塞呢,这样只要调用这些操作,如果相应的事件未准备好,就立马返回 EWOULDBLOCK 或 EAGAIN 错误,此时进程就不会被阻塞了,使用 fcntl 可以可以将 socket 设置为非阻塞,以 read 为例伪代码如下

connfd = accept(listenfd);
fcntl(connfd, F_SETFL, O_NONBLOCK);
// 此时 connfd 变为非阻塞,如果数据未就绪,read 会立即返回
int n = read(connfd, buffer) != SUCCESS; 

read 的非阻塞操作流程图如下

​这样的话调用 read 就不会阻塞等待而会马上返回了,也就实现了非阻塞的效果,不过需要注意的,我们这里说的非阻塞并非严格意义上的非阻塞,这里的非阻塞只是针对网卡数据拷贝到内核缓冲区这一段,如果数据就绪后,再执行 read 此时依然是阻塞的,此时用户进程会占用 CPU 去把数据从内核缓冲区拷贝到用户缓冲区中,可以看到这种模式是同步非阻塞的,这里我们简单解释下阻塞/非阻塞,同步/非同步的概念

  • 阻塞/非阻塞指的是在数据从网卡拷贝到内核缓冲区期间,进程能不能动,如果能动,就是非阻塞的,不能动就是阻塞的

  • 同步/非同步指的是数据就绪后是否需要用户进程亲自调用 read 来搬运数据(将数据从内核空间拷贝到用户空间) ,如果需要,则是同步,如果不需要则是非同步(即异步),异步 I/O 示意图如下:

​异步 IO 执行流程如下:进程发起 I/O 请求后,让内核在整个操作处理完后再通知进程,这整个操作包括网卡拷贝数据到内核缓冲区,将数据从内核缓冲区拷贝到用户缓冲区这两个阶段,内核在处理数据期间(从无数据到拷贝完成),应用进程是可以继续执行其他逻辑的,异步编程需要操作系统支持,目前只有 windows 完美支持,Linux 暂不支持。可以看出异步 I/O 才是真正意义上的非阻塞操作,因为数据从内核缓冲区拷贝到用户缓冲区这一步不需要用户进程来操作,而是由内核代劳了

我们以一个案例来总结下阻塞/非阻塞,同步/异步:当你去餐馆点餐时,如果在厨师做菜期间,你啥也不能干,那就是阻塞,如果在此期间你可以玩手机,喝喝茶,能动,那就是非阻塞,如果厨师做好了菜,你需要亲自去拿,那就是同步,如果厨师做好了,菜由服务员直接送到你的餐桌,那就是非同步(异步)

现在回过头来看将阻塞转成非阻塞是否满足了我们的需求呢?看起来进程确实可以动了,但进程需要不断地以轮询数据的形式调用 accept,read/write 这些操作来询问内核数据是否就绪了,这些都是系统调用,对性能的消耗很大,而且会持续占用 CPU,导致 CPU 负载很高,远不如等数据就绪好了再通知进程去取更高效。这就好比,厨师做菜期间,你不断地去问菜做好了没有,显然没有意义,更高效的方式无疑是等厨师菜做好了主动通知你去取

IO 多路复用

经过前面的分析我们可以得出两个结论

  1. 使用多进程/多线程 IO 模型是不可行的,这一步可以优化为单线程

  2. 应该等数据就绪好了之后再通知用户进程去读取数据,而不是做毫无意义的轮询,注意这里的数据就绪不光是指前文所述的 read 的数据已就绪,而是泛指 accept,read/write 这三个事件的数据都已就绪

于是 IO 多路复用模型诞生了,它是指用一个进程来监听 listen socket(监听 socket) 的连接建立事件,connect socket(已连接 socket) 的读写事件(读写),一旦数据就绪,内核就会唤醒用户进程去处理这些 socket 的相应的事件

​这里简单介绍一下 fd(文件描述符),以便大家更好地了解之后 IO 多路复用中出现的 fd 集合等概念

文件系统简介

我们知道在 Linux 中无论是文件,socket,还是管道,设备等,一切皆文件,Linux 抽象出了一个 VFS(virtual file system) 层,屏蔽了所有的具体的文件,VFS 提供了统一的接口给上层调用,这样应用层只与 VFS 打交道,极大地方便了用户的开发,仔细对比你会发现,这和 Java 中的面向接口编程很类似

通过 open(),socket() 创建文件后,都有一个 fd(文件描述符) 与之对应,对于每一个进程,都有一个文件描述符列表(File Discriptor Table) 来记录其打开的文件,这个列表的每一项都指向其背后的具体文件,而每一项对应的数组下标就是 fd,对于用户而言,可以认为 fd 代表其背后指向的文件

fd 的值从 0 开始,其中 0,1,2 是固定的,分别指向标准输入(指向键盘),标准输出/标准错误(指向显示器),之后每打开一个文件,fd 都会从 3 开始递增,但需要注意的是 fd 并不一定都是递增的,如果关闭了文件,之前的 fd 是可以被回收利用的

IO 多路复用其实也就是用一个进程来监听多个 fd 的数据事件,用户可以把自己感兴趣的 fd 及对应感兴趣的事件(accept,read/write)传给内核,然后内核就会检测 fd ,一旦某个 socket 有事件了,内核可以唤醒用户进程来处理

那么怎样才能知道某个 fd 是否有事件呢,一种很容易想到的做法是搞个轮询,每次调用一下 read(fd),让内核告知是否数据已就绪,但是这样的话如果有 n 个感兴趣的 fd 就会有 n 次 read 系统调用,开销很大,显然不可接受

所以使用 IO 多路复用监听 fd 的事件可行,但必须解决以下三个涉及到性能瓶颈的点

  1. 如何高效将用户感兴趣的 fd 和事件传给内核

  2. 某个 socket 数据就绪后,内核如何高效通知用户进程进行处理

  3. 用户进程如何高效处理事件

前面两步的处理目前有 select,poll,epoll 三种 IO 多路事件模型,我们一起来看看,看完你就会知道为啥 epoll 的性能是如此高效了

select

我们先来看下 select 函数的定义

返回:若有就绪描述符则为其数目,若超时则为 0,若出错则为-1
int select(int maxfd, 
                     fd_set *readset, 
                     fd_set *writeset, 
                     fd_set *exceptset, 
                     const struct timeval *timeout);

maxfd 是待测试的描述符基数,为待测试的最大描述符加 1,readset,writeset,exceptset 分别为读描述符集合,写描述符集合,异常描述符集合,这三个分别通知内核,在哪些描述描述符上检测数据可以读,可写,有异常事件发生,timeout 可以设置阻塞时间,如果为 null 代表一直阻塞

这里需要说明一下,为啥 maxfd 为待测试的描述符加 1 呢,主要是因为数组的下标是从 0 开始的,假设进程新建了一个 listenfd,它的 fd 为 3,那么代表它有 4 个 感兴趣的 fd(每个进程有固定的 fd = 0,1,2 这三个描述符),由此可知 maxfd = 3 + 1 = 4

​接下来我们来看看读,写,异常集合是怎么回事,如何设置针对 fd 的感兴趣事件呢,其实事件集合是采用了一种位结构(bitset)的方式,比如现在假设我们对标准输入(fd = 0),listenfd(fd = 3)的读事件感兴趣,那么就可以在 readset 对应的位上置 1

画外音:使用 FD_SET 可将相应位置置1,如 FD_SET(listenfd, &readset)

如下

​即 readset 为 {1, 0,0, 1},在调用 select 后会将 readset 传给内核,如果内核发现 listenfd 有连接已就绪的事件,则内核也会在将相应位置置 1(其他无就绪事件的 fd 对应的位置为 0)然后会回传给用户线程,此时的 readset 如下,即 {1,0,0,0}

​于是进程就可以根据 readset 相应位置是否是 1(用 FD_ISSET(i, &read_set) 来判断)来判断读事件是否就绪了

需要注意的是由于 accept 的 socket 会越来越多,maxfd 和事件 set 都需要及时调整(比如新 accept 一个已连接的 socket,maxfd 可能会变,另外也需要将其加入到读写描述符集合中以让内核监听其读写事件)

可以看到 select 将感兴趣的事件集合存在一个数组里,然后一次性将数组拷贝给了内核,这样 n 次系统调用就转化为了一次,然后用户进程会阻塞在 select 系统调用上,由内核不断循环遍历,如果遍历后发现某些 socket 有事件(accept 或 read/write 准备好了),就会唤醒进程,并且会把数据已就绪的 socket 数量传给用户进程,动图如下

select 的伪代码如下

int listen_fd,conn_fd; //监听套接字和已连接套接字的变量
listen_fd = socket() //创建套接字
bind(listen_fd)   //绑定套接字
listen(listen_fd) //在套接字上进行监听,将套接字转为监听套接字

fd_set master_rset;  //被监听的描述符集合,关注描述符上的读事件

int max_fd = listen_fd

//初始化 master_rset 数组,使用 FD_ZERO 宏设置每个元素为 0 
FD_ZERO(&master_rset);
//使用 FD_SET 宏设置 master_rset 数组中位置为 listen_fd 的文件描述符为 1,表示需要监听该文件描述符
FD_SET(listen_fd,&master_rset);

fd_set working_set;

while(1) {

   // 每次都要将 master_set copy 给 working_set,因为 select 返回后 working_set 会被内核修改
     working_set = master_set
   /**
    * 调用 select 函数,检测 master_rset 数组保存的文件描述符是否已有读事件就绪,
    * 返回就绪的文件描述符个数,我们只关心读事件,所以其它参数都设置为 null 了
    */
   nready = select(max_fd+1, &working_set, NULL, NULL, NULL);

   // 依次检查已连接套接字的文件描述符
   for (i = 0; i < max_fd && nready > 0; i++) {
      // 说明 fd = i 的事件已就绪
      if (FD_ISSET(i, &working_set)) {
          nready -= 1;
          //调用 FD_ISSET 宏,在 working_set 数组中检测 listen_fd 对应的文件描述符是否就绪
         if (FD_ISSET(listen_fd, &working_set)) {
             //如果 listen_fd 已经就绪,表明已有客户端连接;调用 accept 函数建立连接
             conn_fd = accept();
             //设置 master_rset 数组中 conn_fd 对应位置的文件描述符为 1,表示需要监听该文件描述符
             FD_SET(conn_fd, &master_rset);
             if (conn_fd > max_fd) {
                max_fd = conn_fd;
             }
         } else {
            //有数据可读,进行读数据处理
           read(i, xxx)
        }
      }
    }
}

看起来 select 很好,但在生产上用处依然不多,主要是因为 select 有以下劣势:

  1. 每次调用 select,都需要把 fdset 从用户态拷贝到内核态,在高并发下是个巨大的性能开销(可优化为不拷贝)

  2. 调用 select 阻塞后,用户进程虽然没有轮询,但在内核还是通过遍历的方式来检查 fd 的就绪状态(可通过异步 IO 唤醒的方式)

  3. select 只返回已就绪 fd 的数量,用户线程还得再遍历所有的 fd 查看哪些 fd 已准备好了事件(可优化为直接返回给用户进程数据已就绪的 fd 列表)

正在由于 1,2 两个缺点,所以 select 限制了 maxfd 的大小为 1024,表示只能监听 1024 个 fd 的事件,这离 C10k 显然还是有距离的

poll

poll 的机制其实和 select 一样,唯一比较大的区别其实是把 1024 这个限制给放开了,虽然通过放开限制可以使内核监听上万 socket,但由于以上说的两点劣势,它的性能依然不高,所以生产上也不怎么使用

epoll

接下来我们再来介绍下生产上用得最多的 epoll,epoll 其实和 select,poll 这两个系统调用不一样,它本来其实是个内核的数据结构,这个数据结构允许进程监听多个 socket 的 事件,一般我们通过 epoll_create 来创建这个实例

​然后我们再调用 epoll_ctl 把 感兴趣的 fd 加入到 epoll 实例中的 interest_list,然后再调用 epoll_wait 即可将控制权交给内核,这样内核就会检测此 interest_list,如果发现 socket 已就绪就会把已就绪的 fd 加入到一个 ready_list(简称 rdlist) 中,然后再唤醒用户进程,之后用户进程只要遍历此 rdlist 即可

​为了方便快速对 fd 进行增删改查,必须设计好 interest list 的数据结构,经综合考虑,内核使用了红黑树,而 rdlist 则采用了链表的形式,这样一旦在红黑树上发现了就绪的 socket ,就会把它放到 rdlist 中

epoll 的伪代码如下

int sock_fd,conn_fd; //监听套接字和已连接套接字的变量
sock_fd = socket() //创建套接字
bind(sock_fd)   //绑定套接字
listen(sock_fd) //在套接字上进行监听,将套接字转为监听套接字

epfd = epoll_create(); //创建epoll实例,
//创建epoll_event结构体数组,保存套接字对应文件描述符和监听事件类型    
ep_events = (epoll_event*)malloc(sizeof(epoll_event) * EPOLL_SIZE);

//创建epoll_event变量
struct epoll_event ee
//监听读事件
ee.events = EPOLLIN;
//监听的文件描述符是刚创建的监听套接字
ee.data.fd = sock_fd;

//将监听套接字加入到监听列表中    
epoll_ctl(epfd, EPOLL_CTL_ADD, sock_fd, &ee); 

while (1) {
   //等待返回已经就绪的描述符 
   n = epoll_wait(epfd, ep_events, EPOLL_SIZE, -1); 
   //遍历所有就绪的描述符     
   for (int i = 0; i < n; i++) {
       //如果是监听套接字描述符就绪,表明有一个新客户端连接到来 
       if (ep_events[i].data.fd == sock_fd) { 
          conn_fd = accept(sock_fd); //调用accept()建立连接
          ee.events = EPOLLIN;  
          ee.data.fd = conn_fd;
          //添加对新创建的已连接套接字描述符的监听,监听后续在已连接套接字上的读事件      
          epoll_ctl(epfd, EPOLL_CTL_ADD, conn_fd, &ee); 

       } else { //如果是已连接套接字描述符就绪,则可以读数据
           ...//读取数据并处理
           read(ep_events[i].data.fd, ..)
       }
   }
}

epoll 的动图如下

​可以看到 epoll 很好地解决了 select 的痛点

  1. 「每次调用 select 都把 fd 集合拷贝给内核」优化为「只有第一次调用 epoll_ctl 添加感兴趣的 fd 到内核的 epoll 实例中,之后只要调用 epoll_wait 即可,数据集合不再需要拷贝」

  2. 「用户进程调用 select 阻塞后,内核会通过遍历的方式来同步检查 fd 的就绪状态」优化为「内核使用异步事件通知」

  3. 「select 仅返回已就绪 fd 的数量,用户线程还得再遍历一下所有的 fd 来挨个检查哪个 fd 的事件已就绪了」优化为「内核直接返回已就绪的 fd 集合」

除了以上针对 select 痛点进行的改进之外,epoll 还引入了一种边缘触发(edge trigger,ET)的模式,这种模式也会让 epoll 在高并发下的表现更加优秀,而 select/poll 则只有水平触发模式(level trigger,LT),首先我们来了解一下什么是水平触发和边缘触发

  • 水平触发:只要读缓冲区可读(或可写缓冲区可写),就会一直触发可读(或可写)信号

  • 边缘触发:当套接字的缓冲状态发生变化时才会触发读写信号。对于读缓冲,有新到达的数据被添加到读缓冲时才触发

​对于水平触发而言,只要缓冲区里还有数据,内核就会不停地触发读事件,也就意味着如果收到了大量的数据而应用程序每次只会读取一小部分数据时就会不停地从内核态切换到用户态,浪费大量的内核资源,而对于边缘触发而言,只有在套接字的缓冲状态发生变化(即新收到数据或刚好发出数据)时才会触发读写信号,也就意味着内核只通知唤醒用户进程一次,这在高并发下无疑是更佳选择,当然了也正是由于边缘触发模式下内核只会触发一次的原因,read 要尽可能地将数据全部读走(一般是在一个循环里不断地 read ,直到没有数据),否则一旦没有新的数据进来,缓冲区中剩余的数据就无法读取了

既然 epoll 这么好,那么它的性能到底比 select,poll 强多少呢,关于这一点,我们最好做对其进行做下压测,我们来看下 libevent 框架对 select,poll,Epoll,Kqueue(可以认为是 mac 下的 epoll)的压测数据

​可以看到,在 100 活跃连接(所谓活跃连接就是读写比较频繁),每个连接发生 1000 次读写操作的情况下,随着句柄数量的增加,epoll 和 Kqueue 的响应时间几乎不变,而 select 和 poll 的响应时间则是急遽增加,所以 epoll 非常适合应对大量网络连接,少量活跃连接的情况

不过需要注意一下这里的限制条件:epoll 在应对大量网络连接时,只有在活跃连接数较少的情况下性能才表现优异,如果图中 15000 的网络连接都是活跃连接,那么 epoll 和 select 的表现是差不多的,甚至有可能 epoll 还不如 select,为什么会这样呢?

  1. select/poll 的开销主要是因为无论就绪的 fd 有多少,都要遍历一遍全部的 fd 来找到就绪的 fd 再处理,如果活跃连接数很少,那么很多时间都浪费在遍历上了,但如有很多活跃连接,那遍历的开销就可忽略不计

  2. 为什么活跃连接多,epoll 表现反而不佳呢,其实主要是因为在唤醒过程中 epoll 实现较为复杂,比如为了保证就绪队列的写入安全,使用了自旋锁,如下

static int ep_poll_callback(wait_queue_entry_t *wait, unsigned mode, int sync, void *key)
{
 int pwake = 0;
 unsigned long flags;
 struct epitem *epi = ep_item_from_wait(wait);
 struct eventpoll *ep = epi->ep;
 int ewake = 0;

 /* 获得自旋锁 ep->lock来保护就绪队列
    * 自旋锁ep->lock在 epoll_wait() 调用的 ep_poll() 里被释放
    * /
   spin_lock_irqsave(&ep->lock, flags);

   /* If this file is already in the ready list we exit soon */
 /* 在这里将就绪事件添加到 rdllist */
 if (!ep_is_linked(&epi->rdllink)) {
       list_add_tail(&epi->rdllink, &ep->rdllist);
       ep_pm_stay_awake_rcu(epi);
   }
   ...
}

这样的话如果活跃连接多的话,锁的开销就比较大了

IO 多路复用+非阻塞

那么当 IO 多路程复用检查到数据就绪后(select(),poll(),epoll_wait() 返回后),该怎么处理呢,有人说直接 accept,read/write 不就完了,话是没错,但之前我们也说了,这些操作其实默认是阻塞的,我们需要将其改成非阻塞,为什么呢,数据不是已经就绪了吗,说明 accept,read/write 这些操作可以正常获取数据啊?

其实数据就绪只是说在调用 select(),poll(),epoll_wait() 返回时的数据是就绪的,但当你再去调用 accept,read/write 时可能就会变成未就绪了,举个例子:当某个 socket 接收缓冲区有新数据分节到达,然后 select 报告这个 socket 描述符可读,但随后,协议栈检查到这个新分节有错误,然后丢弃这个分节,这时候调用 read 则无数据可读,这样的话就会产生一个严重的后果:由于线程阻塞在了 read 上,便再也不能调用 select 来监听 socket 事件了,所以 IO 多路程复用一定要和非阻塞配合使用,也就是说要把 listenfd 和 connectfd 设置为非阻塞才行

Reactor 模式

经过以上介绍相信大家对 IO 多路复用的原理有了比较深刻的理解,我们知道 IO 多路程复用是用一个进程来管理多个 socket 的, 那么是否还有优化的空间呢,我们以 select 为例来拆解一下 IO 多路复用的流程

​主要流程如下:调用 select 来监听连接,读写事件,收到事件后判断是否是监听 socket 上的事件,是的话调用 accept(),否则判断是否是已连接 socket 上的读写事件,是的话调用 read(),write()

单进程/线程 Reactor

目前这样的写法没有问题,不过所有的逻辑都藕合在一起,可扩展性不是很好,我们可以将相近的功能划分到同一个模块(以类的形式)中如下

​我们将其分成三个模块,Reactor, Acceptor,Handler,主要工作流程如下

  1. Reactor 对象首先调用 select 来监听 socket 事件,收到事件后会通过 dispatch 分发

  2. 如果是连接建立事件,则由 Acceptor 处理,Acceptor 通过调用 accept 接收连接,并且会创建一个 Handler 来处理后续的读写等事件

  3. 如果不是连接建立事件,则 Reactor 会调用连接对应的 Handler 进行响应,handler 会完成 read,业务处理,write 的完整业务流程

以上这些操作其实和之前的 IO 多路复用一样,所有的的都是由一个进程进行操作的,这里多了一个新名词 Reactor,它指的是对事件的响应,如果来了一个事件就把相应的事件 dispatch 给对应的 acceptor 或 handler 对象来处理,由于整个操作都在一个进程里处理,我们把这种模式称为单 Reactor 模型,单 Reactor 要求对事件的响应要快,比如对数据业务的处理要快,像 Redis 就很适合,因为它的数据都是基于内存操作的(当然像 bigKey 这种异常场景除外)

单 Reactor 多线程模型

如果在单进程 Reactor 模型中,业务处理耗时较长,那么线程就会被阻塞,就无法再处理其它事件了,可能会造成严重的性能问题,而且单进程 Reactor 还有一个劣势,那就是无法充分复用多核的优势,于是人们又提出了 单 Reactor 多线程模型,即把业务处理这一块放到一个线程池中处理

​通过这种方式主进程的压力得到了释放,也充分复用了多核优势来提升并发度

但依然有如下两个瓶颈点

  1. 子线程处理好数据后需要将其传给 handler 进行发送处理,这涉及到共享数据的互斥和保护机制

  2. 主进程承担的所有事件的监听和响应,瞬时的高并发可能成为性能瓶颈

多 Reactor 多进程/线程模型

为以解决单 Reactor 多线程模型存在的两个问题,人们又提出了多 Reactor 多进程/线程模型模块,示意图如下

​工作原理如下

  1. 主进程主要负责 accept 连接,接收后会将其传给 subReactor,subReactor 将其连接加入连接队列中来监控其事件

  2. 一旦子进程中有新的事件被监听到了,则 subReactor 会将其交给 Handler 进入处理

使用这种方式由于数据的 read,业务处理,write 都在一个线程中处理,所以避免了数据的同步加锁操作,父子进程职责很明确,父进程负责 accept,子进程则负责完成后续业务处理

以上介绍的只是标准的 Reactor 模型,但实际上生产上应用的 Reactor 不一定完全遵照这些标准,可能会有一些变化,比如 Nginx 的 Reactor 虽然也是多 Reactor 多进程模型,但它是一种变体:每个子进程都监听了同一个端口,内核接收到连接已建立的事件后会通过负载均衡的方式将其转给其中一个子进程,然后子进程会将其加入到连接队列中监控其事件,监控到事件后也不会转交给其他线程而是自己处理

总结

随着互联网的发展,server 面对的连接越来越多,传统的网络 IO 模型由于在 connect,accept,read/write 这三步中会有阻塞操作,显然无法满足我们 C10K 要求,于是人们提出了多进程/线程模型,每接收一个连接分配一个进程/线程来负责后续的交互,但创建进程/线程本身需要创建堆栈,复制页表等资源,而且进程/线程的上下文切换涉及到用户态,内核态的切换,会造成严重的性能瓶颈,那么把阻塞操作改成非阻塞呢,这样做进程/线程确实是不会被阻塞了,但也意味着 CPU 会做大量的无用功,承担不必要的高负载

综合考虑人们提出了 IO 多路复用这种先进的理念,即一个线程管理监听多个 socket 的事件,当然了其实将 socket 设置成非阻塞的,然后让一个线程不断地去轮询也是能达到一个线程监听多个 socket 的目的,但这样做需要对每个 socket 调用一个 read 系统调用,所以 IO 多路复用还有另一层更重要的意义:将多个系统调用转成一个系统调用再交给内核去监听事件。

IO 多路复用主要有三个模型,select,poll,epoll,每一个都是对前者的改进:

  1. select 是每次调用时都要把 fd 集合拷贝给内核,而且内核是通过不断遍历这种同步的方式来检查 fd 是否有事件就绪,并且一旦检测到有事件后也只是返回有就绪事件的 fd 的个数,用户线程也需要遍历 fd 集合来查看 fd 是否已就绪,select 限制了 fd 的集合只能有 1024 个

  2. poll 和 select 的原理差不多,只不过是放开了 1024 个 fd 的限制,fd 的个数可以任意设置,这样也就让支持 C10k 成为了可能,但由于它的实现机制与 select 类似,所以也存在和 select 一样的性能瓶颈

  3. 为了彻底解决 select,poll 的性能瓶颈,epoll 出现了,它把需要监听的 fd 传给内核 epoll 实例,epoll 以红黑树的形式来管理这些 fd,这样每次 epoll 只需调用 epoll_wait 即可将控制权转给内核来监听 fd 的事件,避免了无意义的 fd 集合的拷贝,同时由于红黑树的高效,一旦某个 socket 来事件了,可以迅速从红黑树中查找到相应的 socket,然后再唤醒用户进程,此过程是异步的,比起 select 的同步唤醒又是一大进步,此时唤醒用户进程后,内核会把数据已就绪的 fd 放到一个就绪列表里传给用户进程,用户进程只需要遍历此就绪列表即可,比起 select 需要全部遍历也是一大进步,除此之外 epoll 引入了边缘触发让其在高并发下的表现也更加优异,正是由于 epoll 对 select,poll 的这些改进,也让它成为了 IO 多路复用绝对的王者

IO 多路复用是指用一个进程/线程去监听多个 socket 的事件,也即意味着一旦事件就绪了进程需要快速地处理这些事件(不然其他 socket 事件的处理的会阻塞),这种对 Redis 非常合适,因为它是基于内存操作的,处理非常快,但对于其它的开源框架,只有一个进程/线程显然是不太满足业务需要的,比如业务处理,可能是 CPU 密集型的,如果只一个进程/线程的话,可能会阻塞在业务处理上,于是人们基于 IO 多路复用又提出了 Reactor 模型,Reactor 即对事件的反应,然后派发事件给相应的处理器,Reator 模型有多个变种,如单 Reactor,单 Reactor 多线程,多 Reacor 多进程/线程模型,这三种模型各有各的优势,主要是为了充分利用多线程/多核来提升性能或是为了避免瞬时的高并发让主线程崩溃

由此可见,网络 IO 模型经历了传统的网络 IO 模型 ---> IO 多路程复用(select,poll,epoll) --> Reactor 模型这三个阶段,主要是为了满足日益增长的 C10k 甚至 C100K 等超高连接数的要求。

参考资料

​推荐一个零声教育C/C++后台开发的免费公开课程,个人觉得老师讲得不错,分享给大家:C/C++后台开发高级架构师,内容包括Linux,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2P,K8S,Docker,TCP/IP,协程,DPDK等技术内容,立即学习

原文:高并发下的网络 IO 模型设计

伺服电机三环控制实战:从参数整定到系统优化 本文以实战视角,深入解析伺服电机三环控制(位置环、速度环、电流环)的参数整定与系统优化全流程。文章摒弃复杂理论,通过生动的比喻和分步调试指南,详细阐述了从电流环快速响应、速度环平滑调节到位置环精准定位的调试方法,并提供了常见问题排查与进阶优化技巧,帮助工程师有效提升伺服系统性能与稳定性。 阅读详情

相关推荐

基于STM32的频率计(采用外部中断的方式)

前言 最近在了解电赛相关的东西,和指导老师交流一下,我决定先从最简单的频率计做起。 频率计是来检测信号的频率的,在做频率计的时候可以用信号发生器发出的信号来进行测试。 原理 这是最基础的方波,我们可以通过检测上升沿的方式来测量其频率。从周期的角度出发连续两个上升沿的时间就是这个方波的周期,那这个周期分之一就是这个方波的频率了。 在思考了一段时间~~(我是萌新。。)~~ 我觉得有两个方法可以实现,第一个是采用stm32定时器的输入捕获功能,第二个就是用外部中断来实现这个功能。正如标题,我这次采用外部中断的方

qq_45784922的博客 6171

mangodb和mysql处理高并发_常用高并发网络线程模型设计及mongodb线程模型优化实践(最全高并发网络IO线程模型设计及优化)...

常用高并发网络线程模型设计及mongodb线程 模型优化实践(最全高并发网络IO线程模型设计)1. 线程模型一. 单线程网络IO复用模型 1.1 说明:1. 所有网络IO事件(accept事件、读事件、写事件)注册到epoll事件集2. 主循环中通过epoll_wait一次性获取内核态收集到的epoll事件信息,然后轮询执行各个事件对应的回调。3. 事件注册、epoll_wait事件获取、事件回...

weixin_36396555的博客 280

STM32N6570-DK ISP调试

将下载线接入STLINK V3EC接口,将BOOT1拨码拨至右边,即将其置为H,上电或已经上电的按复位,打开STM32CubeProgrammer,设置start address:0x70000000。板子消耗电流较大,即使缩短数据线接了USB供电依然不能正常点亮显示屏,最终通过板上CN2端子加了外部5V供电,仍然需要560mA的外部电流。3.烧录bin文件:STM32N6_ISP_IQTune_App_revC01-v1.1.0-trusted.bin。

liu的博客 1067

设计高性能高并发网络

本文围绕设计高性能高并发网络系统的几种网络模型进行了详细阐述介绍

zrush的博客 287

手把手教你用CEFSharp打造防关联指纹浏览器(附完整代码)

本文详细介绍了如何基于CEFSharp框架,从零开始构建一个企业级的防关联指纹浏览器。通过剖析核心架构、多进程隔离实现、动态指纹混淆(如Canvas、WebGL)的实战代码,以及代理集成与性能优化,为跨境电商、广告投放等场景提供了一套可控、安全的开源解决方案。

fern8的博客 967

27、视网膜血管识别与分类的数据集和验证过程

本文介绍了视网膜血管自动识别与分类方法所使用的数据集及其验证过程。通过30张高分辨率的近红外反射视网膜图像,结合专业医生的手动标注结果,构建了包含597个血管段的基准数据集。研究采用准确率、召回率、F1分数和混淆矩阵等评估指标对模型进行验证,并提出了特征增强和分类器优化策略以提升性能。实验结果显示,该方法在复杂区域具有较强的鲁棒性和较高的准确性,为临床应用提供了可靠的依据。

i7j8k9l的博客 148

io多路复用的原理和实现_高并发服务器IO模型

高并发服务器 IO 模型 一、 什么是 IO? 二、 IO 的 5 种模型三、Linux 并发网络编程模型 四、select、epoll、kqueue、IOCP更多c/c++ Linux服务器高阶知识、电子书籍、视频等等请后台私信【架构】获取知识点有C/C++,Linux,golang技术,Nginx,ZeroMQ,MySQL,Redis,fastdfs,MongoDB,ZK,流媒体,CDN,P2...

weixin_39704971的博客 401

基于 Arduino 的鱼缸水质检测控制系统设计

本系统通过多传感器实时采集鱼缸水质参数(pH 值、温度、溶解氧、浊度),经 Arduino 主控芯片处理后,驱动执行模块自动调节水质,并通过显示模块实时展示数据。系统具备阈值报警、自动换水、温度调节、增氧等功能,适用于家庭或小型水族箱的水质智能管理。本设计提供了低成本、易扩展的鱼缸水质管理方案,适用于家庭水族箱或小型水产养殖场景,可根据实际需求调整传感器类型和控制逻辑。注:本设计如有疑问需要解惑可直接私信本人,看我个人简介。

weixin_42300449的博客 1088

从理解Linux操作系统的网络IO模型来理解Netty、Redis...

网络IO模型,例如BIO、NIO是面试中经常被问到的问题,而在Java领域使用的很多网络通信框架或组件如Netty、Redis等其底层原理也绕不开对网络IO模型的理解,在今天的文章中本文...

无敌码农 873

基于STM32、HAL库的ATMXT1066TD触摸屏控制器驱动程序设计

0x11) // 0x11是ATMXT1066的家族ID。// 最多支持10点触摸。// 足够存储10点触摸数据。

corlin6688的博客 164

【同等学力】2005-数学⭐✨

有r个正方形排成一行,今用红、黄、白、蓝四种颜色给这个r个正方形染色,每个正方形只能染一种颜色,如果要求染红、黄、白色的正方形分别至少出现一个,问有多少种不同的染法?3、(4分)设G是一个有n个结点m条边的连通简单平面图,若n≥3,则m≤3n-6.4、(4分)证明:任何连通简单平面图至少有一个结点的度数不超过5

super_mochi1 307

《Linux 网络编程》深入理解五种 IO 模型:从 IO 本质到非阻塞 IO 实战

本文深入解析Linux下五种IO模型,从“等待+拷贝”本质出发,通过钓鱼类比生动阐释阻塞、非阻塞、信号驱动、I/O多路复用与异步IO的工作机制。重点讲解fcntl系统调用实现非阻塞IO的原理与实战,封装Set_NonBlock函数,并详解read返回值处理逻辑,强调区分EWOULDBLOCK与真实错误的重要性。文章理论结合代码,为理解高并发网络编程底层机制奠定基础。

2501_91275995的博客 422

Hermes 教程 03:Skills 系统

摘要:Hermes Skills是一种自我改进机制,可将解决问题的经验保存为可复用技能文档。v0.13.0版本遵循agentskills.io开放标准,与Claude Skills互通。技能创建流程包括发现问题、创建技能文件、加载使用和优化更新四个阶段。系统提供技能检索和自维护机制(Curator),支持技能媒体路由和多种管理命令。内置技能涵盖开发调试、创意头脑风暴等场景,通过积累技能使Hermes更适应用户需求。

程序猿_三产 738

librdkafka网络IO模型:非阻塞IO与连接池的高效实现

librdkafka作为Apache Kafka的C/C++客户端库,其网络IO模型设计对于高性能消息传递至关重要。本文将深入分析librdkafka的非阻塞IO实现、连接管理机制以及高效的事件处理架构。 ## 核心架构设计 ### 非阻塞IO基础 librdkafka采用完全非阻塞的IO模型,基于事件驱动的架构设计。核心组件包括: - **传输层(Transport Layer)**:处...

gitblog_00977的博客 1070

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Reactor模式:高并发网络编程利器

本文介绍了Reactor和Proactor两种网络编程模型。Reactor采用同步非阻塞IO方式,通过事件驱动机制(如epoll)实现高并发处理,适合IO密集型场景如Web服务器、实时通信系统。其核心是将IO操作转化为事件处理,通过回调函数实现解耦。Proactor则是异步IO模型,由内核完成所有IO操作后通知应用层,Windows的IOCP是典型实现。两者关键区别在于:Reactor需主动检查IO就绪状态,而Proactor完全由内核处理IO操作。文章还提供了基于epoll的TCP服务器实现要点,包括事件

2502_92577768的博客 763

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

C++网络编程深度实战:从Socket到Epoll的高并发异步IO

本文深入探讨了高并发服务器性能优化方案,从TCP/IP协议底层出发,系统分析了三代IO模型的演进与差异。重点解析了Epoll事件驱动模型的核心机制,包括其红黑树管理、事件通知原理以及LT/ET两种触发模式的实战选择。通过10万并发Echo服务器的完整实现案例,详细展示了非阻塞Socket设置、Epoll事件注册与循环处理等关键技术点,并对比了Epoll与Select的性能差异(Epoll ET模式可达18000 req/s)。文章还提供了Epoll使用的常见避坑指南,包括非阻塞设置、错误事件处理等关键注意事

huahua8088的博客 992

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Java网络IO模型

从最初的阻塞式 IO(BIO),到基于通道缓冲区的非阻塞 IO(NIO),再到封装优化后的Netty 框架,每一次技术迭代都围绕着 “更高并发、更低开销” 这一核心目标。在实际开发中,没有最好的技术,只有最适合场景的技术,根据业务需求选择合适的 IO 模型,才能实现性能与开发效率的平衡。• 多路复用选择器:Selector 是 NIO 的灵魂,允许一个线程管理多个 Channel,通过监听 Channel 的就绪事件(读就绪、写就绪),实现单线程处理多连接,大幅降低线程开销。

Wang15302191715的博客 1366

高效网络IO测试利器:`asio_benchmark`

高效网络IO测试利器:asio_benchmark 在软件开发中,尤其是涉及网络服务和并发处理时,选择一个高效的IO模型至关重要。 是一个基于 Boost.ASIO 库的性能测试工具,它可以帮助开发者评估和比较不同的 IO 模型在实际场景下的性能表现。 项目简介 asio_benchmark 是由 huyuguang 开发的一个开源项目,其目标是为各种网络编程模型(如同步、异步、回调、线程池等)提...

gitblog_00045的博客 547

如何设计真正高性能高并发分布式系统(万字长文)

“世间可称之为天经地义的事情没几样,复杂的互联网架构也是如此,万丈高楼平地起,架构都是演变而来,那么演变的本质是什么?” —1—引子 软件复杂性来源于几个方面:高并发、高性能、高可用、可扩展、低成本、低规模、可维护、安全等。架构演化、发展都是为了试图降低复杂性: 高并发、高性能:互联网系统特点,用户量大,请求量大,高并发高性能成为必备要求。性能差体验会差,用户会有别的选...

勇往直前的专栏 2590

netty(T-io)详解(包含4种io模型详解)

netty(T-io)详解(包含4种io模型详解)

weixin_45845680的博客 1721

从 BIO 到 AIO 全链路拆解:Reactor 模型演进与高并发 IO 架构落地实战

本文深入解析Java高并发IO模型演进与Reactor架构,从BIO、NIO到AIO的技术发展路径。首先介绍UNIX五种IO模型标准,详细对比同步/异步、阻塞/非阻塞的核心差异。重点剖析NIO的三大组件(Channel、Buffer、Selector)实现原理,并通过完整代码示例展示BIO/NIO/AIO的服务端与客户端实现。系统讲解Reactor模型的三个阶段演进:单线程→单Reactor多线程→主从Reactor多线程,结合Netty框架展示工业级实现方案。最后提供线程模型优化、TCP参数调优等最佳实践

果酱 の 博客 657

为什么你的网络服务扛不住高并发?基于io_uring的C++解决方案来了

解决高并发网络性能瓶颈,本文深入剖析C++实现高性能网络库(基于 io_uring/kqueue)的底层机制。适用于高频通信、低延迟服务等场景,通过异步非阻塞I/O提升吞吐量与响应速度。架构清晰,性能卓越,值得收藏。

FastSolve的博客 714

Linux 高级 IO:从 5 种 IO 模型到 epoll 与 Reactor 模式

IO 的核心:减少 “等待” 时间占比,让进程只处理就绪的 IO。多路复用选型:低并发用 select/poll,高并发必用 epoll(ET 模式 + 非阻塞 IO)。高性能落地:基于 epoll ET + Reactor 模式,是 Linux 高并发网络编程的标准方案。从阻塞 IO 到 epoll,本质是把 “进程等 IO” 的工作逐步转移给内核,让内核替我们做更高效的 “筛选”,最终实现 “进程只处理有效 IO” 的目标。

2302_81335080的博客 418

Java程序员从笨鸟到菜鸟(四十二) 高并发网络模型

一、常用的处理并发网络编程方案 1. IO 多路复用模型 思路:单进程调用 select() 函数来处理多个连接请求 优点:单进程可同时处理多个网络连接请求 缺点:最大并发数为 1024 个,当并发数较大时,处理性能很低 2. 多进程模型 思路:当有连接请求时,主进程 fork 产生一个子进程,让子进程与客户端连接进行数据通信,当客户端主动关闭连接时,子进程结束运行 优点:模式简单,...

u013090299的博客 341

Redis单线程模型为何能高并发?详解网络层Reactor与IO多路复用实现

从 Redis 高并发表象切入,很多人会疑惑:单线程如何支撑海量请求?本质上,Redis 网络层采用 Reactor 模式,基于 epoll 等 IO 多路复用机制实现事件循环,由内核只反馈就绪 socket,主线程串行处理读写事件。相比多线程模型,它避免了锁竞争与上下文切换开销,在内存级命令场景下具备天然优势。理解这一原理,既能解答 Redis 为什么快,也能指导生产调优:如关注慢命令、大 Key 对事件循环的拖累,以及 Redis 6.0 IO 多线程只分担读写而非执行逻辑的事实。掌握事件流转与回调注册

weixin_30702441的博客 326

Linux-io多路复用

IO多路复用允许单线程高效监测多个文件描述符的IO就绪状态,广泛用于TCP服务器处理多客户端请求及阻塞设备的非阻塞IO。Linux提供select与epoll两种机制:select采用轮询方式,最大支持1024个fd,性能随数量增加下降;epoll基于事件驱动,使用红黑树管理fd,通过内核主动通知就绪事件,支持海量监听,时间复杂度O(1),且仅返回就绪列表,避免无效遍历,显著提升效率。

2401_86256335的博客 221
上一篇: 备战2023秋招,应届生应做好哪些准备
下一篇: 网络IO是如何一步一步走向零拷贝的
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值