select和epoll

select：

1，select有数量限制。因为一个进程所打开的FD（文件描述符）是有限制的，所以该函数调用可以操作的文件描述符有最大数量的限制，由FD_SETSIZE决定，内核默认的最大值是：32*32=1024

2，效率低。函数调用过后，需要轮询所有的文件描述符来判断哪个文件描述符可以读写。如果文件描述符的总量很大，而可以读写的文件描述符很少，那么效率是很低的。

3. 内核/用户空间 内存拷贝问题，如何让内核把 FD 消息通知给用户空间呢？在这个问题上 select 采取了内存拷贝方法。

poll是对select的改进，但是只改进了第一个问题；后面两个缺点一样存在。

epoll：

1，数量不受限，可以认为定义数量。

2，效率高。不采用轮询方式，而只对可以读写的文件描述符进行操作。

epoll的使用方式如下：

epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。

1. int epoll_create(int size);
功能   ：生成一个epoll专用的文件描述符(或句柄)。
参数   ：size: 在该epoll fd上关注的最大socket fd数。 自从linux2.6.8之后，size参数是被忽略的。
返回值：生成的文件描述符。
需要注意:当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。
功能  ：控制某个epoll文件描述符上的事件，可以注册事件，修改事件，删除事件。
参数  ：
     参数epfd  ：由epoll_create生成的epoll专用的文件描述符；
     参数op    ：用三个宏来表示：
               EPOLL_CTL_ADD：注册新的fd到epfd中；
               EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
               EPOLL_CTL_DEL：从epfd中删除一个fd；
     参数fd    ：关联的文件描述符；
     参数event ：指向epoll_event的指针；
返回值： 0：成功； 
          -1：失败；
  struct epoll_event(第四个参数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设为边缘触发(Edge Triggered)模式，
          这是相对于水平触发(Level Triggered)来说的。
  EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，
          需要再次把这个socket加入到EPOLL队列里
3. int epoll_wait(int epfd, structepoll_event * events, int maxevents, int timeout);
功能  ：轮询I/O事件的发生。
参数  ：    epfd        ：由 epoll_create 生成的epoll专用的文件描述符，即epoll_create的返回值；
            events      ：用于回传待处理事件的数组；参数events 收集在epoll监控的事件中已经发生的事件。
                             参数events是分配好的epoll_event结构体数组，epoll将会把发生的事件赋值到events数组
                             中（events不可以是空指针，内核只负责把数据复制到这个events数组中，不会去帮助我们
                             在用户态中分配内存）。
            maxevents ：每次能处理的事件数； 这个 maxevents的值不能大于创建epoll_create()时的size.
            timeout     ：等待I/O事件发生的超时值；-1相当于阻塞，0相当于非阻塞；
返回值：      >=0     ：返回发生事件数； 
                -1       ：错误；
                     如果函数调用成功，返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时。
4. int epoll_pwait(与函数epoll_wait类似)
int epoll_pwait(int epfd, struct epoll_event *events,
                   int maxevents, int timeout,
                   const sigset_t *sigmask); 
与epoll_wait的区别是可以通过最后一个参数设置阻塞过程中信号屏蔽字。
上面的函数原型等价于：
sigset_toriginmask;
sigpromask(SIG_SETMASK,&sigmask,& originmask);
ready = epoll_wait(epfd,&events,maxevents,timeout);
sigpromask(SIG_SETMASK,&  originmask ,NULL);

示例如下：

服务器端代码：

#include <sys/epoll.h>  
#include <netinet/in.h>  
#include <sys/types.h>          /* See NOTES */  
#include <sys/socket.h>  
#include <string.h>  
#include <stdio.h>  
#include <unistd.h>  
#include <fcntl.h>  
  
#include <errno.h>  
#include <stdlib.h>  
typedef struct sockaddr_in sockaddr_in ;  
typedef struct sockaddr     sockaddr ;  
  
#define SER_PORT    8080  
  
int nonblock(int fd){  
    int opt ;  
    opt = fcntl(fd,F_GETFL);  
    opt |= O_NONBLOCK ;  
    return fcntl(fd,F_SETFL,opt);  
}  
  
int main(int argc,char**argv){  
    sockaddr_in srv, cli ;  
    int listen_fd ,con_fd ;  
    socklen_t  len;  
    int res ,nsize,ws;  
    char buf[255];  
  
    int epfd,ers;  
    struct epoll_event evn,events[50];  
    int i;  
  
    bzero(&srv,sizeof(srv));  
    bzero(&cli,sizeof(cli));  
    srv.sin_port= SER_PORT ;  
    srv.sin_family = AF_INET ;  
    listen_fd = socket(AF_INET,SOCK_STREAM,0);  
  
    int yes = 1;  
    setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int));  
  
    if(bind(listen_fd,(sockaddr*)&srv,sizeof(sockaddr))<0)  {  
        perror("bind");  
        exit(0);  
    }  
    listen(listen_fd,100);  
    nonblock(listen_fd);  
    epfd = epoll_create(200);  
    evn.events = EPOLLIN|EPOLLET ;  
    evn.data.fd = listen_fd;   
    epoll_ctl(epfd,EPOLL_CTL_ADD,listen_fd,&evn);  
    static int count ;  
    while(1){  
        ers = epoll_wait(epfd,events,100,5000);  
        if(ers<0 ){  
            perror("epoll_wait:");exit(0);  
        }else if(ers==0){  
            printf("time out:%d\n",count++);  
            continue ;  
        }  
        for(i=0;i<ers;i++){  
            if(events[i].data.fd == listen_fd){  
                con_fd = accept(listen_fd,(sockaddr*)&cli ,&len);  
                nonblock(con_fd);  
                printf("connect from:%s\n",inet_ntoa(cli.sin_addr));  
                evn.data.fd = con_fd;  
                evn.events = EPOLLIN | EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_ADD,con_fd,&evn);  
  
            }else if(events[i].events & EPOLLIN){     
                  
                nsize = 0;  
                while((res=read(events[i].data.fd,buf+nsize,sizeof(buf)-1))>0){  
                    nsize+= res;  
                }  
                if(res==0){  
                    epoll_ctl(epfd,EPOLL_CTL_DEL,events[i].data.fd,NULL);     
                    printf("a client over\n");  
                    close(con_fd);  
                    continue ;  
                }else if(res<0 && errno!=EAGAIN){  
                    perror("read");  
                    continue ;  
                }  
                buf[nsize]=0;  
                evn.data.fd = events[i].data.fd;  
                evn.events=EPOLLOUT|EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_MOD,events[i].data.fd,&evn);                 
                  
            }else if(events[i].events & EPOLLOUT){  
                nsize = strlen(buf);  
                ws = 0;  
                while(nsize>0){  
                     ws=write(events[i].data.fd,buf,nsize);  
                    nsize-=ws;  
                }  
                evn.data.fd = events[i].data.fd;  
                evn.events=EPOLLIN|EPOLLET ;  
                epoll_ctl(epfd,EPOLL_CTL_MOD,events[i].data.fd,&evn);     
            }else{  
                printf("others\n");  
                  
            }             
        }  
  
    }  
  
    close(listen_fd);  
      
    return 0;  
}  

客户端代码：

#include <sys/epoll.h>  
#include <netinet/in.h>  
#include <sys/types.h>          /* See NOTES */  
#include <sys/socket.h>  
#include <strings.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
typedef struct sockaddr_in sockaddr_in ;  
typedef struct sockaddr     sockaddr ;  
  
#define SER_PORT    8080  
#define IP_ADDR     "10.33.28.230"  
  
int main(int argc,char**argv){  
    sockaddr_in srv, cli ;  
    int listen_fd ,con_fd ;  
    socklen_t  len;  
    int res,ws ;  
    char buf[255];  
  
    bzero(&srv,sizeof(srv));  
    bzero(&cli,sizeof(cli));  
    srv.sin_port= SER_PORT ;  
    srv.sin_family = AF_INET ;  
    inet_pton(AF_INET,IP_ADDR,&srv.sin_addr);  
  
    listen_fd = socket(AF_INET,SOCK_STREAM,0);  
    if(connect(listen_fd,(sockaddr*)&srv,sizeof(sockaddr))<0){  
        perror("connect");  
        exit(0);  
    }  
    while(1){  
        res = read(STDIN_FILENO,buf,sizeof(buf)-1);  
        ws = write(listen_fd,buf,res);  
        res = read(listen_fd,buf,sizeof(buf)-1);  
        ws = write(STDOUT_FILENO,buf,res);  
    }  
  
    close(listen_fd);  
      
    return 0;  
}