IO

select函数用法 && 阻塞与非阻塞IO

select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或多个发生了状态改变。关于文件句柄，其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。 http://blog.csdn.net/zhandoushi1982/article/details/5070107
函数原型是：

int select(int n,fd_set * readfds,fd_set * writefds,fd_set * exceptfds,struct timeval * timeout);  

参数n代表文件描述词加1；参数readfds、writefds 和exceptfds 称为描述词组，是用来回传该描述词的读，写或例外的状况。下面的宏提供了处理这三种描述词组的方式：
* FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位
* FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真　　
* FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位
* FD_ZERO（fd_set *set）；用来清除描述词组set的全部位
参数timeout为结构timeval，用来设置select()的等待时间，其结构定义如下：

struct timeval{       time_t tv_sec;       time_t tv_usec;};

如果参数timeout设为NULL，则表示select()没有timeout。
select函数执行结果：执行成功则返回文件描述词状态已改变的个数；如果返回0代表在描述词状态改变前已超过timeout时间，没有返回；当有错误发生时则返回-1，错误原因存于errno，此时参数readfds，writefds，exceptfds和timeout的值变成不可预测。错误值可能为：
* EBADF 文件描述词为无效的或该文件已关闭
* EINTR 此调用被信号所中断
* EINVAL 参数n 为负值。
* ENOMEM 核心内存不足
常见的程序片段如下：

fs_set readset；FD_ZERO(&readset);FD_SET(fd,&readset);select(fd+1,&readset,NULL,NULL,NULL);if(FD_ISSET(fd,readset){……}

检测键盘有无输入，完整的程序如下：

#include<sys/time.h>#include<sys/types.h>#include<unistd.h>#include<string.h>#include<stdlib.h>#include<stdio.h>int main(){        char buf[10]="";        fd_set rdfds;        struct timeval tv;        int ret;        FD_ZERO(&rdfds);        FD_SET(0,&rdfds);   //文件描述符0表示stdin键盘输入         tv.tv_sec = 3;        tv.tv_usec = 500;        ret = select(1,&rdfds,NULL,NULL,&tv);      //第一个参数是监控句柄号+1        if(ret<0)              printf("selcet error\r\n");        else if(ret == 0)              printf("timeout \r\n");        else              printf("ret = %d \r\n",ret);        if(FD_ISSET(0,&rdfds)){         //监控输入的确是已经发生了改变              printf(" reading");              read(0,buf,9);                 //从键盘读取输入         }         write(1,buf,strlen(buf));          //在终端中回显         printf(" %d \r\n",strlen(buf));         return 0;} 

阻塞（Ｂlock）
当进程调用一个阻塞的系统函数时，该进程被置于睡眠(Sleep)状态，这时内核调度其它进程运行，直到该进程等待的事件发生了(比如网络上接收到数据包，或者调用sleep 指定的睡眠时间到了)它才有可能继续运行。与睡眠状态相对的是运行(Running)状态，在Linux内核中处于运行状态的进程分为两种情况： 正在被调度执行和就绪状态。
假设一个进程同时监视多个设备，如果read(设备1)是阻塞的，那么只要设备1没有数据到达就会一直阻塞在设备1的read 调用上，即使设备2有数据到达也不能处理，使用非阻塞I/O就可以避免设备2得不到及时处理。
在open 一个设备时指定了O_NONBLOCK 标志，read / write 就不会阻塞。以read 为例，如果设备暂时没有数据可读就返回-1，同时置errno 为EWOULDBLOCK(或者EAGAIN,这两个宏定义的值相同),表示本来应该阻塞在这里，那么调用者不是阻塞在这里死等，这样可以同时监视多个设备。
非阻塞I/O有一个缺点，如果所有设备都一直没有数据到达，调用者需要反复查询做无用功，如果阻塞在那里操作系统可以调度别的进程执行，就不会做无用功了。select(2) 函数可以阻塞地同时监视多个设备，还可以设定阻塞等待的超时时间，从而圆满地解决了这个问题。

poll

使用POLL也可以实现同样的功能，且调用方式更加简单。
原型是：

struct pollfd { int fd;        //文件描述符 short events;  //要求查询的事件掩码 short revents; //返回的事件掩码};int poll(struct pollfd *ufds, unsigned int nfds, int timeout); 

poll函数使用pollfd类型的结构来监控一组文件句柄，ufds是要监控的文件句柄集合，nfds是监控的文件句柄数量，timeout是等待的毫秒数，这段时间内无论I/O是否准备好，poll都会返回。timeout为负数表示无线等待，timeout为0表示调用后立即返回。执行结果：为0表示超时前没有任何事件发生；-1表示失败；成功则返回结构体中revents不为0的文件描述符个数。pollfd结构监控的事件类型如下：

#define POLLIN 0x0001#define POLLPRI 0x0002#define POLLOUT 0x0004#define POLLERR 0x0008#define POLLHUP 0x0010#define POLLNVAL 0x0020#define POLLRDNORM 0x0040#define POLLRDBAND 0x0080#define POLLWRNORM 0x0100#define POLLWRBAND 0x0200#define POLLMSG 0x0400#define POLLREMOVE 0x1000#define POLLRDHUP 0x2000

如上是events事件掩码的值域，POLLIN|POLLPRI类似于select的读事件，POLLOUT|POLLWRBAND类似于select的写事件。当events属性为POLLIN|POLLOUT，表示监控是否可读或可写。在poll返回时，即可通过检查revents变量对应的标志位与events是否相同，比如revents中POLLIN事件标志位被设置，则表示文件描述符可以被读取。代码段示例：

int sockfd;             //套接字句柄struct pollfd pollfds;int timeout;timeout = 5000;pollfds.fd = sockfd;                //设置监控sockfdpollfds.events = POLLIN|POLLPRI;            //设置监控的事件for(;;){    switch(poll(&pollfds,1,timeout)){       //开始监控    case -1:                    //函数调用出错        printf("poll error \r\n");    break;    case 0:        printf("time out \r\n");    break;    default:                    //得到数据返回        printf("sockfd have some event \r\n");        printf("event value is 0x%x",pollfds.revents);    break;    }} 

epoll

epoll是Linux内核为处理大批量文件描述符而作了改进的poll，是Linux下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率。另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而加入Ready队列的描述符集合就行了。epoll除了提供select/poll那种IO事件的水平触发（Level Triggered）外，还提供了边缘触发（Edge Triggered），这就使得用户空间程序有可能缓存IO状态，减少epoll_wait/epoll_pwait的调用，提高应用程序效率。那么为什么我们要使用epoll 进行大量的io 呢？

在linux的网络编程中，很长的时间都在使用select来做事件触发。在linux新的内核中，有了一种替换它的机制，就是epoll。
相比于select，epoll最大的好处在于它不会随着监听fd数目的增长而降低效率。因为在内核中的select实现中，它是采用轮询来处理的，轮询的fd数目越多，自然耗时越多。并且，在linux/posix_types.h头文件有这样的声明：

#define __FD_SETSIZE    1024

表示select最多同时监听1024个fd，当然，可以通过修改头文件再重编译内核来扩大这个数目，但这似乎并不治本。
epoll的接口非常简单，一共就三个函数：
* int epoll_create(int size);
创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。这个参数不同于select()中的第一个参数，给出最大监听的fd+1的值。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
* 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，第四个参数是告诉内核需要监听什么事，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设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket的话，需要再次把这个socket加入到EPOLL队列里

• int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
  等待事件的产生，类似于select()调用。参数events用来从内核得到事件的集合，maxevents告之内核这个events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。

• 关于ET、LT两种工作模式：
  可以得出这样的结论:
  ET模式仅当状态发生变化的时候才获得通知,这里所谓的状态的变化并不包括缓冲区中还有未处理的数据,也就是说,如果要采用ET模式,需要一直read/write直到出错为止,很多人反映为什么采用ET模式只接收了一部分数据就再也得不到通知了,大多因为这样;而LT模式是只要有数据没有处理就会一直通知下去的.

那么究竟如何来使用epoll呢？其实非常简单。
通过在包含一个头文件#include

    for( ; ; )    {        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            {                //其他的处理            }        }    }

下面给出一个完整的服务器端例子：

#include <iostream>#include <sys/socket.h>#include <sys/epoll.h>#include <netinet/in.h>#include <arpa/inet.h>#include <fcntl.h>#include <unistd.h>#include <stdio.h>#include <errno.h>using namespace std;#define MAXLINE 5#define OPEN_MAX 100#define LISTENQ 20#define SERV_PORT 5000#define INFTIM 1000void setnonblocking(int sock){    int opts;    opts=fcntl(sock,F_GETFL);    if(opts<0)    {        perror("fcntl(sock,GETFL)");        exit(1);    }    opts = opts|O_NONBLOCK;    if(fcntl(sock,F_SETFL,opts)<0)    {        perror("fcntl(sock,SETFL,opts)");        exit(1);    }}int main(int argc, char* argv[]){    int i, maxi, listenfd, connfd, sockfd,epfd,nfds, portnumber;    ssize_t n;    char line[MAXLINE];    socklen_t clilen;    if ( 2 == argc )    {        if( (portnumber = atoi(argv[1])) < 0 )        {            fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);            return 1;        }    }    else    {        fprintf(stderr,"Usage:%s portnumber/a/n",argv[0]);        return 1;    }    //声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件    struct epoll_event ev,events[20];    //生成用于处理accept的epoll专用的文件描述符    epfd=epoll_create(256);    struct sockaddr_in clientaddr;    struct sockaddr_in serveraddr;    listenfd = socket(AF_INET, SOCK_STREAM, 0);    //把socket设置为非阻塞方式    //setnonblocking(listenfd);    //设置与要处理的事件相关的文件描述符    ev.data.fd=listenfd;    //设置要处理的事件类型    ev.events=EPOLLIN|EPOLLET;    //ev.events=EPOLLIN;    //注册epoll事件    epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);    bzero(&serveraddr, sizeof(serveraddr));    serveraddr.sin_family = AF_INET;    char *local_addr="127.0.0.1";    inet_aton(local_addr,&(serveraddr.sin_addr));//htons(portnumber);    serveraddr.sin_port=htons(portnumber);    bind(listenfd,(sockaddr *)&serveraddr, sizeof(serveraddr));    listen(listenfd, LISTENQ);    maxi = 0;    for ( ; ; ) {        //等待epoll事件的发生        nfds=epoll_wait(epfd,events,20,500);        //处理所发生的所有事件        for(i=0;i<nfds;++i)        {            if(events[i].data.fd==listenfd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。            {                connfd = accept(listenfd,(sockaddr *)&clientaddr, &clilen);                if(connfd<0){                    perror("connfd<0");                    exit(1);                }                //setnonblocking(connfd);                char *str = inet_ntoa(clientaddr.sin_addr);                cout << "accapt a connection from " << str << endl;                //设置用于读操作的文件描述符                ev.data.fd=connfd;                //设置用于注测的读操作事件                ev.events=EPOLLIN|EPOLLET;                //ev.events=EPOLLIN;                //注册ev                epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);            }            else if(events[i].events&EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。            {                cout << "EPOLLIN" << endl;                if ( (sockfd = events[i].data.fd) < 0)                    continue;                if ( (n = read(sockfd, line, MAXLINE)) < 0) {                    if (errno == ECONNRESET) {                        close(sockfd);                        events[i].data.fd = -1;                    } else                        std::cout<<"readline error"<<std::endl;                } else if (n == 0) {                    close(sockfd);                    events[i].data.fd = -1;                }                line[n] = '/0';                cout << "read " << line << endl;                //设置用于写操作的文件描述符                ev.data.fd=sockfd;                //设置用于注测的写操作事件                ev.events=EPOLLOUT|EPOLLET;                //修改sockfd上要处理的事件为EPOLLOUT                //epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);            }            else if(events[i].events&EPOLLOUT) // 如果有数据发送            {                sockfd = events[i].data.fd;                write(sockfd, line, n);                //设置用于读操作的文件描述符                ev.data.fd=sockfd;                //设置用于注测的读操作事件                ev.events=EPOLLIN|EPOLLET;                //修改sockfd上要处理的事件为EPOLIN                epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);            }        }    }    return 0;}