Linux网络编程：IO复用

一、select

用途：在一段指定时间内，监听用户感兴趣的文件描述符上的可读、可写和异常等事件。

1、API

#include <sys/select.h>
int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, struct timeval* timeout);
	- nfds: 指定被监听的文件描述符的总数。它通常被设置为select监听的所有文件描述中的最大值加1，因为文件描述是从0开始计数的。
    - readfds：可读文件描述符集合
    - writefds：可写文件描述符集合
    - exceptfds：异常文件描述符集合
    - timeout：
        - struct timeval{
            long tv_sec; // 秒数
            long tv_usec; // 微秒数
        }
	- 返回
        成功：>0 返回就绪文件描述符的总数
             =0 超时时间内没有任何文件描述符就绪
      	失败：-1并设置errno，如果在select等待期间，程序接收到信号，则select立即返回-1，并设置errno为EINTR
// fd_set结构体
FD_ZERO(fd_set *fdset); // 清除fdset的所有位
FD_SET(int fd, fd_set *fdset); // 设置fdset的位fd
FD_CLR(int fd, fd_set *fdset); // 清除fdset的位fd
int FD_ISSET(int fd, fd_set *fdset); // 测试fdset的位fd是否被设置

// fd_set结构体
#include <typesizes.h>
#define _FD_SETSIZE 1024

#include <sys/select.h>
#define FD_SETSIZE _FD_SETSIZE
typedef long int _fd_mask;
#undef _NFDBITS
#define _NFDBITS (8*(int)sizeof (_fd_mask))
typedef struct
{
#ifdef _USE_XOPEN
    _fd_mask fds_bits[_FD_SETSIZE/_NFDBITS];
#define _FDS_BITS(set) ((set)->fds_bits)
#else
    _fd_mask _fds_bits[_FD_SETSIZE / _NFDBITS];
#define _FDS_BITS(set) ((set)->_fds_bits)
#endif
}fd_set;
fd_set结构体包含一个整型数组，该数组的每一个元素的每一位(bit)标记一个文件描述符。fd能容纳的文件描述符数量由FD_SETSIZE指定。
                                                                              

2、demo

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

int main(int argc, char* argv[] ){
  if(argc <= 2){
    printf("usage: %s ip_address port_number\n", basename(argv[0]));
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi(argv[2]);

  int ret = 0;
  struct sockaddr_in address;
  bzero(&address, sizeof(address));
  address.sin_family = AF_INET;
  inet_pton(AF_INET, ip, &address.sin_addr);
  address.sin_port = htons(port);

  int listenfd = socket(PF_INET, SOCK_STREAM, 0);
  assert(listenfd >= 0);
  ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
  assert(ret != -1);
  ret = listen(listenfd, 5);
  assert(ret != -1);
  struct sockaddr_in client_address;
  socklen_t client_addrlength = sizeof(client_address);
  int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
  if (connfd < 0) {
    printf("errno is: %d\n", errno);
    close(listenfd);
  }
  char buf[1024];
  fd_set read_fds;
  fd_set exception_fds;
  FD_ZERO(&read_fds);
  FD_ZERO(&exception_fds);

  while (1) {
    memset(buf, '\0', sizeof(buf));
    FD_SET(connfd, &read_fds);
    FD_SET(connfd, &exception_fds);
    ret = select(connfd + 1, &read_fds, NULL, &exception_fds, NULL);
    if (ret < 0) {
      printf("selection failure.\n");
      break;
    }

    /* 对于可读事件，采用普通的recv函数读取数据*/
    if (FD_ISSET(connfd, &read_fds)) {
      ret = recv(connfd, buf, sizeof(buf) - 1, 0);
      if(ret <= 0){
        break;
      }
      printf("get %d bytes of normal data；%s\n", ret,buf);
    } else if (FD_ISSET(connfd, &exception_fds)) {
       /*对于异常事件，采用带MSG_OOB标志的recv函数读取带外数据*/
      ret = recv(connfd, buf, sizeof(buf) - 1, MSG_OOB);
      if (ret <= 0) {
        break;
      }
      printf("get %d bytes of oob data：%s\n", ret, buf);
    }
  }
    
  close(connfd);
  close(listenfd);
  return 0;
}

二、poll

1、API

#include <poll.h>
int poll(struct pollfd * fds, nfds_t nfds, int timeout);
	- fds：参数是一个pollfd结构类型的数组
        struct pollfd{
            int fd; // 文件描述符
            short events; // 注册的事件，告诉poll监听fd上的哪些事件
            short revents; //实际发生的事件，由内核填充，通知应用程序fd实际上发生哪些事件
		}
	- nfds：指定被监听事件集合fds的大小
        typedef unsigned long int nfd_t;
    - timeout：指定poll的超时值，单位为毫秒
        -1：poll将永远阻塞，直到某个事件发生
         0：poll调用将立即返回
	- 返回
        成功：>0 返回就绪文件描述符的总数
             =0 超时时间内没有任何文件描述符就绪
      	失败：-1并设置errno

poll事件类型

事件	描述	是否可作为输入	是否可作为输出
POLLIN	数据（包括普通数据和优先数据）可读	是	是
POLLRDNORM	普通数据可读	是	是
POLLDBAND	优先级带数据可读（Linux不支持）	是	是
POLLPRI	高优先级数据可读，比如TCP带外数据	是	是
POLLOUT	数据（包括普通数据和优先数据）可写	是	是
POLLWRNORM	普通数据可写	是	是
POLLWRBAND	优先级带数据可写	是	是
POLLRDHUP	TCP连接被对方关闭，或者对方关闭了写操作。它由GNU引入	是	是
POLLERR	错误	否	是
POLLHUP	挂起。比如管道的写端被关闭后，读端描述符上将收起POLLHUP事件	否	是
POLLNVAL	文件描述符没有打开	否	是

三、epoll

1、API

int epoll_create(int size);
- 作用: 创建epoll文件描述符，来识别内核中事件表
- 参数: 
	size：并不起什么作用，指定一个大于 0 的数值
- 返回:
	epoll文件描述符
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
- 作用：管理红黑树实例上的节点，可以进行添加、删除、修改操作
- 参数：
	- epfd：epoll文件描述符
	- op：指定操作类型 
    	- EPOLL_CTL_ADD: 往事件表中注册fd上的事件
		- EPOLL_CTL_MOD: 修改fd上的注册事件
		- EPOLL_CTL_DEL: 删除fd上的注册事件
    - fd：要操作的文件描述符
    - event：指定事件
       struct epoll_event{
           _uint32_t events;  // epoll事件
           epoll_data_t data; // 用户数据
       };
		events
			- EPOLLIN：读事件，接收数据，检测读缓冲区，如果有数据该文件描述符就绪
			- EPOLLOUT：写事件，发送数据，检测写缓冲区，如果可写该文件描述符就绪
			- EPOLLERR：异常事件
		data
            用于存储用户数据
           typedef union epoll_data{
               void* ptr;
               int fd;
               uint32_t u32;
               uint64_t u64;
           } epoll_data_t;
			ptr成员可以用来指定与fd相关的数据。但由于epoll_date_t是一个联合体，不能同时使用ptr和fd，
                可以放弃fd，使用ptr指向的用户数据中包含fd
- 返回：
    成功 0
    失败 -1并设置errno

int epoll_wait(int epfd, struct epoll_event *events, int maxevent, int timeout);
作用：
    在一段超时时间内等待一组文件描述符的事件
参数：
	- epfd：epoll文件描述符
    - events: 将所有就绪的事件从内核事件表（由epfd参数指定）中复制到events中
    - maxevents；指定最多监听多少个事件，大于0
    - timeout：指定poll的超时值，单位为毫秒
        -1：poll将永远阻塞，直到某个事件发生
         0：poll调用将立即返回
返回：
	- 成功：就绪的文件描述符的个数
	- 失败：-1并设置errno

poll和epoll使用的差别

// 如何索引poll返回就绪文件描述符
int ret = poll(fds, MAX_EVENT_NUMBER, -1);
// 必须遍历所有已注册文件描述符并找到其中的就职者（当然，可以利用 ret 优化）、
for (int i = 0; i < MAX_EVENT_NUMBER, i++) {
  if(fds[i].revents & POLLIN){
    int sockfd  = fads[i].fd;
  }
}

//  epoll返回就绪
int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
for (int i = 0; i < ret; i+) {
  int sockfd = events[i].data.fd;
}

2、工作模式

a、水平模式(LT模式)

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

b、边沿模式(ET模式)

当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续epoll_wait调用将不再向应用程序通知这一事件。只能非阻塞(non-block)接收数据

c、demo

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 10

// 将文件描符设置成非阻塞
int setnonblocking(int fd) {
  int old_option = fcntl(fd, F_GETFL);
  int new_option = old_option | O_NONBLOCK;
  fcntl(fd, F_SETFL, new_option);
  return old_option;  
}

// 将文件描符fd上的EPOLLIN注册到epollfd指示的epoll内核事件表中，参数enable_et决定是否启用ET模式
void addfd(int epollfd, int fd, bool enable_et) {
  epoll_event event;
  event.data.fd = fd;
  event.events = EPOLLIN;
  if(enable_et){
      event.events |= EPOLLET;
  }
  epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
  setnonblocking(fd);
}

// LT模式的工作流程
void lt(epoll_event* events, int number, int epollfd, int listenfd) {
  char buf[BUFFER_SIZE];
  for (int i = 0; i < number; i++) {
    int sockfd = events[i].data.fd;
    if (sockfd == listenfd) {
      struct sockaddr_in client_address;
      socklen_t client_addrlength = sizeof(client_address);
      int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);

      addfd(epollfd, connfd, false);
    } else if (events[i].events & EPOLLIN) {
      // 只要socket读缓存中还有未读出的数据，这段代码就被触发
      printf("event trigger once\n");
      memset(buf, '\0', BUFFER_SIZE);
      int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
      if (ret <= 0) {
        close(sockfd);
        continue;
      }
      printf("get %d bytes of content: %s\n", ret, buf);
    } else {
      printf("something else happened\n");
    }
  }
}

// ET模式的工作流程
void et(epoll_event* events, int number, int epollfd, int listenfd) {
  char buf[BUFFER_SIZE];
  for (int i = 0; i < number; i++) {  
    int sockfd = events[i].data.fd;
    if (sockfd == listenfd) {
      struct sockaddr_in client_address;
      socklen_t client_addrlength = sizeof(client_address);
      int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
      addfd(epollfd, connfd, true); // 对connfd开启ET模式
    } else if (events[i].events & EPOLLIN){
     // 这段代码不会被重复触发，所以我们循环读取数据，以确保把socket读缓存中的所有数据读出
      printf("event trigger once\n");
      while (1) {
        memset(buf, '\0', BUFFER_SIZE);
        int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);

        if (ret < 0) {
          // 对于非阻塞IO，下面的条件成立表示数据已经全部读取完毕。此后，
          // epoll就能再次触发sockfd上的EPOLLIN事件，以驱动下一次读操作
          if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
            printf("read later\n");
            break;
          }
          close(sockfd);
          break;
        } else if (ret == 0) {
          close(sockfd);
        } else {
          printf("get %d bytes of content: %s\n",ret, buf);
        }
      }
    } else {
        printf("something else happened\n");
    }
  }
}

int main(int argc, char* argv[]){
  if(argc <= 2){
    printf("usage: %s ip_address port_number\n", basename(argv[0]));
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi(argv[2]);

  int ret = 0;
  struct sockaddr_in address;
  bzero(&address, sizeof(address));
  address.sin_family = AF_INET;
  inet_pton(AF_INET, ip, &address.sin_addr);
  address.sin_port = htons(port);

  int listenfd = socket(PF_INET, SOCK_STREAM, 0);
  assert(listenfd >= 0);

  ret = listen(listenfd, 5);
  assert(ret != -1);

  epoll_event events[MAX_EVENT_NUMBER];
  int epollfd = epoll_create(5);
  assert(epollfd != -1);

  addfd(epollfd, listenfd, true);

  while (1) {
    int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
    if (ret < 0) {
      printf("epoll failure\n");
      break;
    }
        
    lt(events, ret, epollfd, listenfd); // 使用LT模式
    // et(events, ret, epollfd, listenfd); // 使用ET模式
  }

  close(listenfd);
  return 0;
}

3、EPOLLONESHOT事件

一个线程（或进程，下同）在读取完某个socket上的数据后开始处理这些数据，而在数据的处理过程中该socket上又有新数据可读（EPOLLIN再次次触发），此时另外一个线程被唤醒来读取这些新的数据。于是就出现了两个线程同时操作一个socket的局面。

demo

#include<sys/types.h>
#include<sys/socket.h>
#include<sys/epoll.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<assert.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<fcntl.h>
#include<stdlib.h>
#include<pthread.h>

#define MAX_EVENT_NUMBER 1024
#define BUFFER_SIZE 1024

struct fds {
  int epollfd;
  int sockfd;
};

int setnonblocking(int fd) {
  int old_option = fcntl(fd,F_GETFL);
  int new_option = old_option | O_NONBLOCK;
  fcntl(fd,F_SETFL,new_option);
  return old_option;
}

// 将fd上EPOLLET和EPOLLONESHOT事件注册到epollfd指示的epoll内核事件表中，
// 参数oneshot指定是否注册fd上EPOLLONESHOT事件
void addfd(int epollfd,int fd,bool oneshot) {
  epoll_event event;
  event.data.fd = fd;
  event.events = EPOLLIN | EPOLLET;
  if (oneshot) {
    event.events |= EPOLLONESHOT;
  }
  epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
  setnonblocking(fd);
}

// 重置fd上的事件。这样操作之后，尽管fd上EPOLLONESHOT事件被注册，
// 但是操作系统仍然会触发fd上的EPOLLIN事件，且只触发一次
void reset_oneshot(int epollfd,int fd) {
  epoll_event event;
  event.data.fd = fd;
  event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
  epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&event);
}
// 工作线程
void* worker(void *arg) {
 int sockfd = ((fds*)arg)->sockfd;
 int epollfd = ((fds*)arg)->epollfd;
 printf("start new thread to receive data on fd%d\n", sockfd);
 char buf[BUFFER_SIZE];
 memset(buf,'\0',BUFFER_SIZE);
 // 循环读取sockfd上的数据，直到遇到EAGIN错误
 while(1){
   int ret = recv(sockfd, buf, BUFFER_SIZE-1, 0);
   if (ret == 0) {
    close(sockfd);
    printf("foreiner closed the connection\n");
    break;
   } else if (ret < 0) {
     if(errno == EAGAIN){
       reset_oneshot(epollfd, sockfd);
       printf("read later\n");
     }
   } else {
    printf("get content: %s\n", buf);
    // 休眠5s，模拟数据处理过程
    sleep(5);
   }
 }
 printf("end thread which receive data on fd%d\n", sockfd);
}

int main(int argc,char* argv[]) {
  if(argc <= 2){
    printf("usage: %s ip_address port_number\n", basename(argv[0]));
    return 1;
  }
  const char* ip = argv[1];
  int port = atoi(argv[2]);

  int ret = 0;
  struct sockaddr_in address;
  bzero(&address,sizeof(address));
  address.sin_family = AF_INET;
  inet_pton(AF_INET, ip, &address.sin_addr);
  address.sin_port = htons(port);

  int listenfd = socket(PF_INET, SOCK_STREAM, 0);
  assert(listenfd >= 0);

  ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
  assert(ret != -1);

  ret = listen(listenfd, 5);
  assert(ret != -1);

  epoll_event events[MAX_EVENT_NUMBER];
  int epollfd = epoll_create(5);
  assert(epollfd != -1);

  // 注意，监听sockfd listenfd上是不能注册EPOLLONESHOT事件的，否则应用程序只能处理一个客户连接！
  // 因为后续客户连接请求将不再触发listenfd上的EPOLLIN事件
  addfd(epollfd, listenfd, false);

  while (1) {
    int ret = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
    if(ret < 0){
      printf("epoll failure\n");
      break;
    }

    for (int i = 0;i < ret;i++) {
      int sockfd = events[i].data.fd;
      if (sockfd == listenfd) {
        struct sockaddr_in client_address;
        socklen_t client_addrlength = sizeof(client_address);
        int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);

        // 对每个非监听文件描述符都注册EPOLLONESHOT事件
        addfd(epollfd,connfd,true);
      } else if (events[i].events & EPOLLIN) {
        pthread_t thread;
        fds fds_for_new_worker;
        fds_for_new_worker.epollfd = epollfd;
        fds_for_new_worker.sockfd = sockfd;

        // 新启动一个工作线程为sockfd服务
        pthread_create(&thread, NULL, worker, (void*)&fds_for_new_worker);
      } else {
        printf("something else happened\n");
      }
    }
  }

  close(listenfd);
  return 0;
}

四、区别

系统调用	select	poll	epoll
事件集合	用户通过3个参数分别传入感兴趣的可读、可写及异常事件，内核通过对这些参数的在线修改来反馈其中的就绪事件。这使得用户每次调用select都要重置3个参数	统一处理所有事件类型，因此只需一个事件集参数。用户通过pollfd.events传入感兴趣的事件，内核通过修改pollfd.events反馈其中就绪的事件	内核通过一个事件表直接管理用户感兴趣的所有事件。因此每次调用epoll_wait时，无须反复传入用户感兴趣的事件。epoll_wait系统调用的参数events仅用来反馈就绪的事件
应用程序检测	返回的集合需要判断(O(n))	返回的集合需要判断(O(n))	直接得到已就绪的文件描述符集合(O(1))
最大支持文件描述符数	一般有最大限制	65535	65535
工作模式	LT	LT	支持ET高效模式
内核实现和工作效率	采用轮询方式来检测就绪事件，算法时间复杂度为O(n)	采用轮询方式来检测就绪事件，算法时间复杂度为O(n)	采用回调方式来检测就绪事件，算法时间复杂度为O(n)
底层数据结构	线性表	线性表	红黑树
内存拷贝	内核/用户空间数据的频繁拷贝问题	内核/用户空间数据的频繁拷贝问题	内核/用户区使用的是共享内存（基于mmap内存映射区实现）