手把手写c++服务器(31):服务器性能提升关键——io复用技术两万字长文(代码片段)

沉迷单车的追风少年 沉迷单车的追风少年     2022-12-28     402

关键词:

 本系列文章导航: 手把手写C++服务器(0):专栏文章-汇总导航【更新中】 

前言: Linux中素有“万物皆文件,一切皆IO”的说法。前面几讲手撕了CGI网关服务器、echo回显服务器、discard服务的代码,但是这几个一次只能监听一个文件描述符,因此性能非常原始、低下。IO复用能使服务器同时监听多个文件描述符,是服务器性能提升的关键。虽然IO复用本身是阻塞的,但是和并发技术结合起来,再加上一点设计模式,一个高性能服务器的基石就基本搭建完成了。

目录

1、预备知识

(1)文件描述符

(2)进程阻塞

(3)缓存IO

(4)什么是IO多路复用?

2、Linux五大IO模型

(1)阻塞IO

(2)非阻塞IO

(3)IO多路复用

(4)信号驱动IO

(5)异步IO

3、select

函数返回

参数详解

重要结构体详解

使用流程

代码实例

4、poll

函数原型

重要结构体详解

事件类型

使用流程

代码实例

5、epoll

函数原型

函数返回

LT水平触发模式和ET边沿触发模式

代码实例

6、三组IO复用函数对比

1. 用户态将文件描述符传入内核的方式

2. 内核态检测文件描述符读写状态的方式

3. 找到就绪的文件描述符并传递给用户态的方式

4. 重复监听的处理方式

7、经典面试题:epoll更高效的原因

写在最后

参考


1、预备知识

(1)文件描述符

强烈推荐看一下本系列的第25讲《手把手写C++服务器(25):万物皆可文件之socket fd

文件描述符(File descriptor)是计算机科学中的一个术语,是一个用于表述指向文件的引用的抽象化概念。 文件描述符在形式上是一个非负整数。实际上,它是一个索引值,指向内核为每一个进程所维护的该进程打开文件的记录表。当程序打开一个现有文件或者创建一个新文件时,内核向进程返回一个文件描述符。在程序设计中,一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

(2)进程阻塞

正在执行的进程,由于期待的某些事件未发生,如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作做等,则由系统自动执行阻塞原语(Block),使自己由运行状态变为阻塞状态。可见,进程的阻塞是进程自身的一种主动行为,也因此只有处于运行态的进程(获得了CPU资源),才可能将其转为阻塞状态。当进程进入阻塞状态,是不占用CPU资源的。

(3)缓存IO

缓存I/O又称为标准I/O,大多数文件系统的默认I/O操作都是缓存I/O。在Linux的缓存I/O机制中,操作系统会将I/O的数据缓存在文件系统的页缓存中,即数据会先被拷贝到操作系统内核的缓冲区中,然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。

缓存 I/O 的缺点:

数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作,这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。

(4)什么是IO多路复用?

IO 多路复用是一种同步IO模型,实现一个线程可以监视多个文件句柄;一旦某个文件句柄就绪,就能够通知应用程序进行相应的读写操作;没有文件句柄就绪就会阻塞应用程序,交出CPU。

2、Linux五大IO模型

(1)阻塞IO

这是最常用的简单的IO模型。阻塞IO意味着当我们发起一次IO操作后一直等待成功或失败之后才返回,在这期间程序不能做其它的事情。阻塞IO操作只能对单个文件描述符进行操作,详见readwrite

(2)非阻塞IO

我们在发起IO时,通过对文件描述符设置O_NONBLOCK flag来指定该文件描述符的IO操作为非阻塞。非阻塞IO通常发生在一个for循环当中,因为每次进行IO操作时要么IO操作成功,要么当IO操作会阻塞时返回错误EWOULDBLOCK/EAGAIN,然后再根据需要进行下一次的for循环操作,这种类似轮询的方式会浪费很多不必要的CPU资源,是一种糟糕的设计。和阻塞IO一样,非阻塞IO也是通过调用readwrite来进行操作的,也只能对单个描述符进行操作。

(3)IO多路复用

IO多路复用在Linux下包括了三种,selectpollepoll,抽象来看,他们功能是类似的,但具体细节各有不同:首先都会对一组文件描述符进行相关事件的注册,然后阻塞等待某些事件的发生或等待超时。IO多路复用都可以关注多个文件描述符,但对于这三种机制而言,不同数量级文件描述符对性能的影响是不同的,下面会详细介绍。

(4)信号驱动IO

信号驱动IO是利用信号机制,让内核告知应用程序文件描述符的相关事件。

但信号驱动IO在网络编程的时候通常很少用到,因为在网络环境中,和socket相关的读写事件太多了,比如下面的事件都会导致SIGIO信号的产生:

  1. TCP连接建立
  2. 一方断开TCP连接请求
  3. 断开TCP连接请求完成
  4. TCP连接半关闭
  5. 数据到达TCP socket
  6. 数据已经发送出去(如:写buffer有空余空间)

上面所有的这些都会产生SIGIO信号,但我们没办法在SIGIO对应的信号处理函数中区分上述不同的事件,SIGIO只应该在IO事件单一情况下使用,比如说用来监听端口的socket,因为只有客户端发起新连接的时候才会产生SIGIO信号。

(5)异步IO

异步IO和信号驱动IO差不多,但它比信号驱动IO可以多做一步:相比信号驱动IO需要在程序中完成数据从用户态到内核态(或反方向)的拷贝,异步IO可以把拷贝这一步也帮我们完成之后才通知应用程序。我们使用 aio_read 来读,aio_write 写。

同步IO vs 异步IO

1. 同步IO指的是程序会一直阻塞到IO操作如read、write完成

2. 异步IO指的是IO操作不会阻塞当前程序的继续执行
所以根据这个定义,上面阻塞IO当然算是同步的IO,非阻塞IO也是同步IO,因为当文件操作符可用时我们还是需要阻塞的读或写,同理IO多路复用和信号驱动IO也是同步IO,只有异步IO是完全完成了数据的拷贝之后才通知程序进行处理,没有阻塞的数据读写过程。

3、select

select的作用是在一段指定的时间内,监听用户感兴趣的文件描述符上的可读、可写、异常等事件。函数原型如下:

#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
                fd_set *exceptfds, struct timeval *timeout);

函数返回

  • select成功时返回就绪文件描述符的总数;
  • 如果在超时时间内没有任何文件描述符就绪,select将返回0;
  • select失败时返回-1并设置errno。;
  • 如果在select等待期间,程序接收到信号,select立即返回-1,并将errno设置为EINTR。

参数详解

  • nfds:指定被监听文件描述符总数。通常被设置为select监听所有文件描述符中的最大值+1。
  • readfds:可读事件对应文件描述符集合。
  • writefds:可写事件对应文件描述符集合。
  • exceptfds:异常事件对应文件描述符集合。
  • timeout:设置select超时时间。

重要结构体详解

readfds、writefds、exceptfds都是fd_set结构体,timeout是timeval结构体,这里详解一下这两个结构体。

1、fd_set

fd_set结构体定义比较复杂,涉及到位操作,比较复杂。所以通常用宏来访问fd_set中的位。

#include <sys/select.h>
FD_ZERO(fd_set* fdset);    // 清除fdset中的所有位
FD_SET(int fd, fd_set* fdset); // 设置fdset中的位
FD_CLR(int fd, fd_set* fdset); // 清除fdset中的位
int FD_ISSET(int fd, fd_set* fdset);  // 测试fdset的位fd是否被设置
  • FD_ZERO用来清空文件描述符组。每次调用select前都需要清空一次。
  • FD_SET添加一个文件描述符到组中,FD_CLR对应将一个文件描述符移出组中。
  • FD_ISSET检测一个文件描述符是否在组中,我们用这个来检测一次select调用之后有哪些文件描述符可以进行IO操作。

2、timeval

struct timeval 
    long tv_sec; // 秒数
    long tv_usec; // 微妙数
;

使用流程

综上所述,我们一般的使用流程是:

  1. 准备工作——定义readfds、timeval等
  2. 使用FD_ZERO清零,使用FD_SET设置文件描述符。因为事件发生后,文件描述符集合都将被内核修改。
  3. 调用select
  4. 使用FD_ISSET检测文件描述符是否在组中

代码实例

根据使用流程,给出一个代码示例:

#include <stdio.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

#define TIMEOUT 5 /* select timeout in seconds */
#define BUF_LEN 1024 /* read buffer in bytes */

int main (void) 
  struct timeval tv;
  fd_set readfds;
  int ret;
  
  /* Wait on stdin for input. */
  FD_ZERO(&readfds);
  FD_SET(STDIN_FILENO, &readfds);
  /* Wait up to five seconds. */
  tv.tv_sec = TIMEOUT;
  tv.tv_usec = 0;
  
  /* All right, now block! */
  ret = select (STDIN_FILENO + 1, &readfds,
                NULL,
                NULL, 
                &tv);
  if (ret == −1) 
    perror ("select");
    return 1; 
   else if (!ret) 
    printf ("%d seconds elapsed.\\n", TIMEOUT);
    return 0; 
  
  /*
  * Is our file descriptor ready to read?
  * (It must be, as it was the only fd that
  * we provided and the call returned
  * nonzero, but we will humor ourselves.)
  */
  if (FD_ISSET(STDIN_FILENO, &readfds)) 
    char buf[BUF_LEN+1];
    int len;
    /* guaranteed to not block */
    len = read (STDIN_FILENO, buf, BUF_LEN);
    if (len == −1) 
      perror ("read");
      return 1; 
    
    if (len) 
      buf[len] = '\\0';
      printf ("read: %s\\n", buf);
    
    return 0; 
  

  fprintf (stderr, "This should not happen!\\n");
  return 1; 

后面一讲会给出一些实用的例子,有了select之后我们可以同时监听很多个请求,系统的处理能力大大增强了。

4、poll

和select类似,在一定时间内轮询一定数量的文件描述符。

函数原型

#include <poll.h>
int poll(struct pollfd* fds, nfds_t nfds, int timeout);

但是和select不同的是,select需要用三组文件描述符,poll只有一个pollfd文件数组,数组中的每个元素都表示一个需要监听IO操作事件的文件描述符。而且我们只需要关心数组中events参数,revents由内核自动填充。

重要结构体详解

    struct pollfd 
        int fd;    // 文件描述符
        short events;    // 注册的事件 
        short revents;   // 实际发生的事件,由内核填充
    ;

事件类型

具体的事件类型参看手册:https://man7.org/linux/man-pages/man2/poll.2.html

       POLLIN There is data to read.

       POLLPRI
              There is some exceptional condition on the file
              descriptor.  Possibilities include:

              • There is out-of-band data on a TCP socket (see tcp(7)).

              • A pseudoterminal master in packet mode has seen a state
                change on the slave (see ioctl_tty(2)).

              • A cgroup.events file has been modified (see cgroups(7)).

       POLLOUT
              Writing is now possible, though a write larger than the
              available space in a socket or pipe will still block
              (unless O_NONBLOCK is set).

       POLLRDHUP (since Linux 2.6.17)
              Stream socket peer closed connection, or shut down writing
              half of connection.  The _GNU_SOURCE feature test macro
              must be defined (before including any header files) in
              order to obtain this definition.

       POLLERR
              Error condition (only returned in revents; ignored in
              events).  This bit is also set for a file descriptor
              referring to the write end of a pipe when the read end has
              been closed.

       POLLHUP
              Hang up (only returned in revents; ignored in events).
              Note that when reading from a channel such as a pipe or a
              stream socket, this event merely indicates that the peer
              closed its end of the channel.  Subsequent reads from the
              channel will return 0 (end of file) only after all
              outstanding data in the channel has been consumed.

       POLLNVAL
              Invalid request: fd not open (only returned in revents;
              ignored in events).

       When compiling with _XOPEN_SOURCE defined, one also has the
       following, which convey no further information beyond the bits
       listed above:

       POLLRDNORM
              Equivalent to POLLIN.

       POLLRDBAND
              Priority band data can be read (generally unused on
              Linux).

       POLLWRNORM
              Equivalent to POLLOUT.

       POLLWRBAND
              Priority data may be written.

使用流程

综上所述,我们一般的使用流程是:

  1. 定义pollfd数组,并设置poll数组相关参数。
  2. 设置超时时间
  3. 调用poll

代码实例

根据使用流程,给出一个代码示例:

#include <stdio.h>
#include <unistd.h>
#include <poll.h>
#define TIMEOUT 5 /* poll timeout, in seconds */
int main (void) 
  struct pollfd fds[2];
  int ret;
  /* watch stdin for input */
  fds[0].fd = STDIN_FILENO;
  fds[0].events = POLLIN;
  /* watch stdout for ability to write (almost always true) */
  fds[1].fd = STDOUT_FILENO;
  fds[1].events = POLLOUT;
  /* All set, block! */
  ret = poll (fds, 2, TIMEOUT * 1000);
  if (ret == −1) 
    perror ("poll");
    return 1; 
  
  if (!ret) 
    printf ("%d seconds elapsed.\\n", TIMEOUT);
    return 0; 
  

  if (fds[0].revents & POLLIN)
    printf ("stdin is readable\\n");
  if (fds[1].revents & POLLOUT)
    printf ("stdout is writable\\n");
  return 0; 

5、epoll

epoll是Linux特有的IO复用函数,使用一组函数来完成任务,而不是单个函数。

epoll把用户关心的文件描述符上的事件放在内核的一个事件表中,不需要像select、poll那样每次调用都要重复传入文件描述符集或事件集。

epoll需要使用一个额外的文件描述符,来唯一标识内核中的时间表,由epoll_create创建。

函数原型

    #include <sys/epoll.h>

    int epoll_create(int size);
    int epoll_create1(int flags);

    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

    int epoll_wait(int epfd, struct epoll_event *events,
                int maxevents, int timeout);
    int epoll_pwait(int epfd, struct epoll_event *events,
                int maxevents, int timeout,
                const sigset_t *sigmask);
  • epoll_create:创建一个epoll实例,size参数给内核一个提示,标识事件表的大小。函数返回的文件描述符将作用其他所有epoll系统调用的第一个参数,以指定要访问的内核事件表。
  • epoll_ctl:操作文件描述符。fd表示要操作的文件描述符,op指定操作类型,event指定事件。
  • epoll_wait:在一段超时时间内等待一组文件描述符上的事件。如果监测到事件,就将所有就绪的事件从内核事件表(epfd参数指定)中复制到第二个参数events指向的数组中。因为events数组只用于输出epoll_wait监测到的就绪事件,而不像select、poll那样就用于传入用户注册的事件,又用于输出内核检测到的就绪事件。这样极大提高了应用程序索引就绪文件描述符的效率。

函数返回

特别注意epoll_wait函数成功时返回就绪的文件描述符总数。select和poll返回文件描述符总数。

以寻找已经就绪的文件描述符,举个例子如下:

epoll_wait只需要遍历返回的文件描述符,但是poll和select需要遍历所有文件描述符

//  poll
int ret = poll(fds, MAX_EVENT_NUMBER, -1);
// 必须遍历所有已注册的文件描述符
for (int i = 0; i < MAX_EVENT_NUMBER; i++) 
    if (fds[i].revents & POLLIN) 
        int sockfd = fds[i].fd;
    


// epoll_wait
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
// 仅需要遍历就绪的ret个文件描述符
for (int i = 0; i < ret; i++) 
    int sockfd = events[i].data.fd;

LT水平触发模式和ET边沿触发模式

epoll监控多个文件描述符的I/O事件。epoll支持边缘触发(edge trigger,ET)或水平触发(level trigger,LT),通过epoll_wait等待I/O事件,如果当前没有可用的事件则阻塞调用线程。

select和poll只支持LT工作模式,epoll的默认的工作模式是LT模式。

水平触发:

  • 当epoll_wait检测到其上有事件发生并将此事件通知应用程序后,应用程序可以不立即处理此事件。这样应用程序下一次调用epoll_wait的时候,epoll_wait还会再次向应用程序通告此事件,直到事件被处理。

边沿触发:

  • 当epoll_wait检测到其上有事件发生并将此事件通知应用程序后,应用程序必须立即处理此事件,后续的epoll_wait调用将不再向应用程序通知这一事件。

所以,边沿触发模式很大程度上降低了同一个epoll事件被重复触发的次数,所以效率更高

代码实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXEVENTS 64

static int make_socket_non_blocking (int sfd)

  int flags, s;

  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    
      perror ("fcntl");
      return -1;
    

  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    
      perror ("fcntl");
      return -1;
    

  return 0;


static int create_and_bind (char *port)

  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;

  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */

  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    
      fprintf (stderr, "getaddrinfo: %s\\n", gai_strerror (s));
      return -1;
    

  for (rp = result; rp != NULL; rp = rp->ai_next)
    
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        
          /* We managed to bind successfully! */
          break;
        

      close (sfd);
    

  if (rp == NULL)
    
      fprintf (stderr, "Could not bind\\n");
      return -1;
    

  freeaddrinfo (result);

  return sfd;


int main (int argc, char *argv[])

  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;

  if (argc != 2)
    
      fprintf (stderr, "Usage: %s [port]\\n", argv[0]);
      exit (EXIT_FAILURE);
    

  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();

  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();

  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    
      perror ("listen");
      abort ();
    

  efd = epoll_create1 (0);
  if (efd == -1)
    
      perror ("epoll_create");
      abort ();
    

  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1)
    
      perror ("epoll_ctl");
      abort ();
    

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
	
	  if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
	    
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
	      fprintf (stderr, "epoll error\\n");
	      close (events[i].data.fd);
	      continue;
	    

	  else if (sfd == events[i].data.fd)
	    
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len);
                  if (infd == -1)
                    
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        
                          /* We have processed all incoming
                             connections. */
                          break;
                        
                      else
                        
                          perror ("accept");
                          break;
                        
                    

                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\\n", infd, hbuf, sbuf);
                    

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();

                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    
                      perror ("epoll_ctl");
                      abort ();
                    
                
              continue;
            
          else
            
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;

              while (1)
                
                  ssize_t count;
                  char buf[512];

                  count = read (events[i].data.fd, buf, sizeof buf);
                  if (count == -1)
                    
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        
                          perror ("read");
                          done = 1;
                        
                      break;
                    
                  else if (count == 0)
                    
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    

                  /* Write the buffer to standard output */
                  s = write (1, buf, count);
                  if (s == -1)
                    
                      perror ("write");
                      abort ();
                    
                

              if (done)
                
                  printf ("Closed connection on descriptor %d\\n",
                          events[i].data.fd);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
                  close (events[i].data.fd);
                
            
        
    

  free (events);

  close (sfd);

  return EXIT_SUCCESS;

6、三组IO复用函数对比

1. 用户态将文件描述符传入内核的方式

  • select:创建3个文件描述符集并拷贝到内核中,分别监听读、写、异常动作。这里受到单个进程可以打开的fd数量限制,默认是1024。
  • poll:将传入的struct pollfd结构体数组拷贝到内核中进行监听。
  • epoll:执行epoll_create会在内核的高速cache区中建立一颗红黑树以及就绪链表(该链表存储已经就绪的文件描述符)。接着用户执行的epoll_ctl函数添加文件描述符会在红黑树上增加相应的结点。

2. 内核态检测文件描述符读写状态的方式

  • select:采用轮询方式,遍历所有fd,最后返回一个描述符读写操作是否就绪的mask掩码,根据这个掩码给fd_set赋值。
  • poll:同样采用轮询方式,查询每个fd的状态,如果就绪则在等待队列中加入一项并继续遍历。
  • epoll:采用回调机制。在执行epoll_ctl的add操作时,不仅将文件描述符放到红黑树上,而且也注册了回调函数,内核在检测到某文件描述符可读/可写时会调用回调函数,该回调函数将文件描述符放在就绪链表中。

3. 找到就绪的文件描述符并传递给用户态的方式

  • select:将之前传入的fd_set拷贝传出到用户态并返回就绪的文件描述符总数。用户态并不知道是哪些文件描述符处于就绪态,需要遍历来判断。
  • poll:将之前传入的fd数组拷贝传出用户态并返回就绪的文件描述符总数。用户态并不知道是哪些文件描述符处于就绪态,需要遍历来判断。
  • epoll:epoll_wait只用观察就绪链表中有无数据即可,最后将链表的数据返回给数组并返回就绪的数量。内核将就绪的文件描述符放在传入的数组中,所以只用遍历依次处理即可。

4. 重复监听的处理方式

  • select:将新的监听文件描述符集合拷贝传入内核中,继续以上步骤。
  • poll:将新的struct pollfd结构体数组拷贝传入内核中,继续以上步骤。
  • epoll:无需重新构建红黑树,直接沿用已存在的即可。

7、经典面试题:epoll更高效的原因?

select和poll的动作基本一致,只是poll采用链表来进行文件描述符的存储,而select采用fd标注位来存放,所以select会受到最大连接数的限制,而poll不会。

select、poll、epoll虽然都会返回就绪的文件描述符数量。但是select和poll并不会明确指出是哪些文件描述符就绪,而epoll会。造成的区别就是,系统调用返回后,调用select和poll的程序需要遍历监听的整个文件描述符找到是谁处于就绪,而epoll则直接处理即可。

select、poll都需要将有关文件描述符的数据结构拷贝进内核,最后再拷贝出来。而epoll创建的有关文件描述符的数据结构本身就存于内核态中。

select、poll采用轮询的方式来检查文件描述符是否处于就绪态,而epoll采用回调机制。造成的结果就是,随着fd的增加,select和poll的效率会线性降低,而epoll不会受到太大影响,除非活跃的socket很多。

epoll的边缘触发模式效率高,系统不会充斥大量不关心的就绪文件描述符。

虽然epoll的性能最好,但是在连接数少并且连接都十分活跃的情况下,select和poll的性能可能比epoll好,毕竟epoll的通知机制需要很多函数回调。

写在最后

这一讲偏理论,主要讲了Linux中三种IO复用。后面几讲会在这一讲的基础上,围绕IO写一些有趣的实战demo,敬请期待。

参考

手把手写c++服务器(34):高并发高吞吐io秘密武器——epoll池化技术两万字长文(代码片段)

本系列文章导航: 手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:前文手把手写C++服务器(31):服务器性能提升关键——IO复用技术【两万字长文】介绍了IO复用技术,其中重点比较了... 查看详情

手把手写c++服务器:专栏文章-汇总导航更新中

手把手写C++服务器(1):网络编程常见误区手把手写C++服务器(2):C/C++编译链接模型、函数重载隐患、头文件使用规范手把手写C++服务器(3):C++编译常见问题、编译优化方法、C++库发... 查看详情

手把手写c++服务器(16):服务端多线程并发编程入门精讲(代码片段)

...c;C++的多线程编程显得臃肿、困难。但是在C++服务器编程当中,多线程是一道绕不开门槛,是提高应用程序响应和性能的重要利器,能够隐藏诸如I/O这样耗时的操作延迟。特别是C++11引入了std::thread之... 查看详情

手把手写c++服务器(26):常用i/o操作创建文件描述符

本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:通过上一篇文章(手把手写C++服务器(25):万物皆可文件之socketfd),Linux万物皆文件的一定深入人心。如何操作这些文件?I/O函数将震撼登场!第一... 查看详情

手把手写c++服务器(25):万物皆可文件之socketfd(代码片段)

 本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:大家一定听说过在Linux当中,万物皆是文件,任何客观的存在都是以文件形式呈现。前面讲socket编程的时候(手把手写C+&... 查看详情

手把手写c++服务器(33):linux常用命令合集

 本系列文章导航: 手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:服务端编程的过程当中,各种常用的命令行也会大量使用;熟悉常用Linux命令不仅仅是运维的基本要求,也是一个主程的基本门槛。这里... 查看详情

手把手写c++服务器(28):手撕cgi通用网关接口服务器代码(代码片段)

 本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:前文《手把手写C++服务器(26):常用I/O操作、创建文件描述符》《手把手写C++服务器(27):五大文件描述符零拷... 查看详情

手把手写c++服务器(27):五大文件描述符零拷贝控制总结(代码片段)

 本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:前文《手把手写C++服务器(26):常用I/O操作、创建文件描述符》、《手把手写C++服务器(25):万物皆可文件之sock... 查看详情

手把手写c++服务器(29):手撕echo回射服务器代码(代码片段)

 本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:上一讲《手把手写C++服务器(28):手撕CGI通用网关接口服务器代码》讲解了如何利用复制文件描述符dup重定位标准输出&#x... 查看详情

手把手写c++服务器(30):手撕代码——基于tcp/ip的抛弃服务discard(代码片段)

 本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:前面两讲讲了echo服务器和CGI网关服务器《手把手写C++服务器(29):手撕echo回射服务器代码》《手把手写C++服务器(2... 查看详情

手把手写c++服务器(32):三大事件之信号详解(代码片段)

本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:信号实际上是一种软中断,信号机制实际上是进程间通信的一种方式。状态改变、系统异常、系统状态的变化等等,这些是... 查看详情

手把手写c++服务器(21):linuxsocket网络编程入门基础(代码片段)

本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】前言:刚开始写C++服务器的时候,我们进行网络编程肯定是使用socketAPI,等熟练之后,会根据我们自己的需要,封装... 查看详情

手把手写c++服务器(22):linuxsocket网络编程进阶第一弹(代码片段)

前言:前面一篇文章手把手写C++服务器(21):Linuxsocket网络编程入门基础,讲解了如何建立socket连接、如何转换/使用socket地址、如何绑定/监听/发起/接受/断开/终止/关闭连接。socket博大精深,进阶会多写几弹&... 查看详情

手把手写c++服务器(22):linuxsocket网络编程进阶第一弹(代码片段)

前言:前面一篇文章手把手写C++服务器(21):Linuxsocket网络编程入门基础,讲解了如何建立socket连接、如何转换/使用socket地址、如何绑定/监听/发起/接受/断开/终止/关闭连接。socket博大精深,进阶会多写几弹&... 查看详情

手把手写c++服务器(23):必知必会!操作系统面试十连问

前言:系列文章手把手写C++服务器(17):自测!TCP协议面试经典十连问受到了大家的收藏和点赞,谢谢读者的支持。操作系统是后端开发工程师的童子功,掌握常见的操作系统基础知识不仅有助于我们日... 查看详情

手把手写c++服务器(17):自测!tcp协议面试经典十连问(代码片段)

前言:前面一篇文章《手把手写C++服务器(15):网络编程入门第一个TCP项目》介绍了一个简单入门级的TCP项目,这一篇文章重点讲一讲面试常见的TCP协议相关的十个问题,都是后端开发程序员必知必会的经典... 查看详情

手把手写c++服务器(17):自测!tcp协议面试经典十连问(代码片段)

前言:前面一篇文章《手把手写C++服务器(15):网络编程入门第一个TCP项目》介绍了一个简单入门级的TCP项目,这一篇文章重点讲一讲面试常见的TCP协议相关的十个问题,都是后端开发程序员必知必会的经典... 查看详情

手把手写c++服务器(24):socket响应一般框架tcp修改缓冲区内核监听listen最大长度(代码片段)

本系列文章导航:手把手写C++服务器(0):专栏文章-汇总导航【更新中】 前言:本系列文章手把手写C++服务器(15):网络编程入门第一个TCP项目以封装好的网络库为例,重点讲解了如何正确的建立TCP... 查看详情