select & epoll

同步、异步、堵塞和非堵塞差别

　　同步：发出一个功能调用时。在没有得到结果之前，该调用就不返回

　　异步：当一个异步过程调用发出后。调用者不能立马得到结果。实际处理这个调用的部件在完毕后。通过状态、通知和回调来通知调用者

　　堵塞：堵塞调用是指调用结果返回之前，当前线程会被挂起。

函数仅仅有在得到结果之后才会返回

　　

　　非堵塞：不能立马得到结果之前，该函数不会堵塞当前线程，而会立马返回

　　

　　同步与堵塞的差别：

　　 - 同步不一定堵塞，对于同步调用来说，许多时候当前线程还是激活的，仅仅是从逻辑上当前函数没有返回而已，如调用recv函数，假设缓冲区中没有数据，这个函数就会一直等待，直到有数据才返回。而此时，当前线程还会继续处理各种各样的消息

　　 - 当socket工作在堵塞模式的时候。 假设没有数据的情况下调用该函数，则当前线程就会被挂起，直到有数据为止

　　同步堵塞：效率最低

　　同步非堵塞：将fd设为O_NONBLOCK，则可马上返回

　　异步堵塞：如selectIO复用。不是在处理消息时堵塞。而是在等待消息被触发时被堵塞

IO多路复用

　　select、poll、epoll都是IO复用机制，IO复用是指在一个线程中同一时候监听多个描写叙述符，一旦有一个描写叙述符就绪。就能够通知程序对该描写叙述符进行读写操作。

　　IO复用的基本方法都是：先构建一张有关描写叙述符的列表。然后使用统一的堵塞函数，在等待消息被触发时被堵塞。当不论什么socket有事件通知时跳出堵塞状态。

　　IO复用本质都是同步IO。只是通过提前堵塞地监听描写叙述符，保证有描写叙述符须要进行读写时才调用相应的同步读写函数。跳过了对每一个描写叙述符的等待过程。提高了并发时的效率。

　　

select

相关接口

• 函数原型

   #include <sys/select.h> //select; 
   #include <sys/time.h> //struct timeval;
   int select(
        int nfds,
        fd_set *readset,
        fd_set *writeset,
        fd_set* exceptset,
        struct timeval *timeout
     );
     //返回已就绪的描写叙述符个数
     //当某些调用出错时，返回-1。可通过errno查看错误代码
     //当超时仍没有事件就绪时，返回0
  

• 參数
  

  • nfds：第一个參数是：最大的文件描写叙述符值+1；
  • readset：可读描写叙述符集合；
  • writeset：可写描写叙述符集合；
  • exceptset：异常描写叙述符；
  • timeout：select 的监听时长。timeout为NULL时，堵塞等待。timeout为0时，马上返回

FD_ZERO(fd_set *)  //清空描写叙述符集合
FD_SET(int, fd_set *)  //向描写叙述符集合增加指定描写叙述符
FD_CLR(int, fd_set *) //从描写叙述符集合删除指定描写叙述符
FD_ISSET(int, fd_set *) //检測指定描写叙述符是否在描写叙述符集合中
#define FD_SETSIZE 1024  //描写叙述符最大数量

select调用的基本框架（以read操作为例）：

fd_set rdset;
listNode *p=head;
int max_fd;
int ret=0;
struct timeval timeout={3,0};  //设置超时时间
while(1){
    //每次调用select之前都要清空fdset。并又一次增加全部描写叙述符
    FD_ZERO(&rdset);
    p=head;
    while(p){        //依次将每一个待监听的描写叙述符增加列表
        FD_SET(p->fd，&rdset);
        if(p->fd>max_fd)
            max_fd=p->fd;
        p=p->next;
    }
    ret=select(max_fd+1,&rdset,NULL,NULL,&timeout);
    if(ret<0)  //返回-1。则出错
        error;
    if(ret==0)  //timeout超时时，仍没有不论什么描写叙述符就绪
        continue;
    for(int i=0;i<=max_fd;++i){
    //依次检測每一个描写叙述符。若就绪，则调用相应的回调函数进行处理
        if(FD_ISSET(i,&rdset){
            callback(i);
        }
    }
}

select的原理

　　select是基于整型数组的，。每一个整型数字有32bit，每一位可表示一个fd。比如假设最大描写叙述符数为1024，则须要1024/32 = 32，即fd_set set为int a[32]。

　　1）每次在调用select之前，都须要通过FD_SET增加待监听的描写叙述符。

　　FD_SET(int fd, fd_set *pSet)；则是将pSet的第fd位置为1（从0開始计数）；如fd = 3，则经过FD_SET后，最后一字节为 0000 1000

　　2）当调用select后，就将各fd_set从用户态copy到内核。当在超时时间内相应的描写叙述符没有事件就绪，则将该位置0.

　　如在调用select之前，调用FD_SET设置了2、 3、 4这三个描写叙述符，则fd_set最低字节为 0001 1100。若在超时时间内，2、 3描写叙述符就绪，4未就绪。

则在超时返回时，fd_set最低字节变为 0000 1100。将改变后的fd_set从内核copy到用户态。

　　3）遍历每一个描写叙述符，通过FD_ISSET推断是否就绪，若就绪。则进行相应处理。

　　尽管能够改变描写叙述符数量的最大值。可是这样会导致数组很大。效率变得很低，因此意义不大。

　　

select的缺陷

　　通过上述对select原理的分析可知，select主要有下面几个缺陷：

　　1）描写叙述符数量的限制。对于高并发的场景1024个描写叙述符远远不够

　　2）每次调用select之前都须要依次向fd_set中增加每一个待监听的描写叙述符

　　3）调用select时，都须要将fd_set从用户态copy到内核，超时时。又要将返回的fd_set从内核copy到用户态

　　4）调用select时，底层是通过轮询每一个描写叙述符来推断是否有描写叙述符就绪的

　　5）select返回的结果仅仅是就绪的描写叙述符的个数，而不是详细事件。因此须要遍历描写叙述符，依次推断每一个描写叙述符是否就绪

epoll

epoll是对select的改进：

　　1）epoll的底层是基于红黑树的，每次增加一个监听的描写叙述符。即是向红黑树中增加一个节点。

　　因此没有最大描写叙述符的限制

　　2）同一时候监听的描写叙述符列表没有发生变化时，底层的红黑树不会发生不论什么变化，因此不再须要每次都又一次增加描写叙述符。

当要新增加或删除某个描写叙述符时，仅仅是在红黑树中增加或删除一个节点

　　3）epoll还相应一个双向链表。每当有一个描写叙述符就绪时，就将该事件增加到双向链表中。

　　当调用epoll_wait等待就绪事件时，内核是通过检查双向链表是否为空来推断是否有事件就绪的，而不用轮询每一个描写叙述符 　　

　　4）epoll採用了共享内存，因此用户空间和内核传递数据不再须要copy，使得效率大大提高

　　5）epoll_wait返回时，还会返回就绪描写叙述符，因此不再须要依次遍历每一个描写叙述符进行推断

　　

epoll的相关接口

　　epoll头文件为　　

#include <sys/epoll.h>

　　epoll**仅仅有epoll_create,epoll_ctl,epoll_wait** 3个系统调用

　　1. int epoll_create(int size);

　　创建一个epoll的句柄。自从linux2.6.8之后，size參数是被忽略的。须要注意的是。当创建好epoll句柄后，它就是会占用一个fd值。所以在使用完epoll后，必须调用close()关闭。否则可能导致fd被耗尽。

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

　　epoll的事件注冊函数。它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注冊要监听的事件类型。

• 第一个參数是epoll_create()的返回值
• 第二个參数表示动作。用三个宏来表示：
  
  EPOLL_CTL_ADD：注冊新的fd到epfd中；
  
  EPOLL_CTL_MOD：改动已经注冊的fd的监听事件；
  
  EPOLL_CTL_DEL：从epfd中删除一个fd。
• 第三个參数是须要监听的fd。
• event：告诉内核须要监听什么事件

struct epoll_event结构例如以下：

//保存触发事件的某个文件描写叙述符相关的数据（与详细使用方式有关）
typedef union epoll_data {
    void *ptr;
    int fd;
    __uint32_t u32;
    __uint64_t u64;
} epoll_data_t;
 //感兴趣的事件和被触发的事件
struct epoll_event {
    __uint32_t events; /* Epoll events */
    epoll_data_t data; /* User data variable */
}; 

events能够是下面几个宏的集合：

• EPOLLIN ：读事件（包含对端SOCKET正常关闭）；
• EPOLLOUT：写事件；
• EPOLLPRI：表示相应的文件描写叙述符有紧急的数据可读（这里应该表示有带外数据到来）；
• EPOLLERR：错误；
• EPOLLHUP：表示相应的文件描写叙述符被挂断；
• EPOLLET： 将EPOLL设为ET模式，这是相对于LT来说的。

• EPOLLONESHOT：仅仅监听一次事件，当监听完这次事件之后。假设还须要继续监听这个socket的话。须要再次把这个socket增加到EPOLL队列里

  3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
  
  　　获得在epoll监听的描写叙述符中已就绪的事件。
  
  　　events是分配好的epoll_event结构体数组。epoll将会把发生的事件赋值到events数组中（events不能够是空指针，内核仅仅负责把数据拷贝到这个events数组中，不会去帮助我们在用户态中分配内存）。
  
  　　maxevents告之内核这个events有多大。这个 maxevents的值不能大于创建epoll_create()时的size，
  
  　　timeout是超时时间
  
  　　假设函数调用成功。返回相应I/O上已准备好的文件描写叙述符数目。如返回0表示已超时。

epoll两种工作模式：

• LT（水平触发）：若程序这次没有处理，下次还会再次通知　　
• ET（边沿触发）：仅仅通知一次，若程序没有处理。后面不会再通知
  
  系统默觉得LT模式

epoll的基本使用框架　　

int epfd;
struct epoll_event event;
struct epoll_event *events;
epfd = epoll_create1 (0);
event.data.fd = listenfd;  //listenfd为server端监听fd
event.events = EPOLLIN | EPOLLET;//读入,边缘触发方式
s = epoll_ctl (efd, EPOLL_CTL_ADD, listenfd, &event);
events = calloc (MAXEVENTS, sizeof event);
while(1)  {
       nfds = epoll_wait(epfd,events,20,500);
       for(i=0;i<nfds;++i)  {
           if(events[i].data.fd==listenfd){ //有新的连接
               connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen); //accept这个连接
               ev.data.fd=connfd;
               ev.events=EPOLLIN|EPOLLET;
               epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev); //将新的fd增加到epoll的监听队列中
           } else if( events[i].events&EPOLLIN ) { //接收到数据，读socket
               n = read(sockfd, line, MAXLINE)) < 0    //读
               ev.data.ptr = md;     //md为自己定义类型，增加数据
               ev.events=EPOLLOUT|EPOLLET;
               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);//改动标识符，等待下一个循环时发送数据，异步处理的精髓
           } else if(events[i].events&EPOLLOUT){ //有数据待发送，写socket
               struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;    //取数据
               sockfd = md->fd;
               send( sockfd, md->ptr, strlen((char*)md->ptr), 0 );        //发送数据
               ev.data.fd=sockfd;
               ev.events=EPOLLIN|EPOLLET;
               epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev); //改动标识符，等待下一个循环时接收数据
           } else  {
               //其它的处理
           }
       }
   }