epoll简介（一）

一：概述  

1：简介

EPOLL类似于POLL，是Linux特有的一种IO多路复用的机制。它在2.5.44内核中引入。

对于大量的描述符处理，EPOLL更有优势，它提供了三个系统调用来创建管理epoll实例：

epoll_create创建一个epoll实例，返回该实例的文件描述符；

epoll_ctl注册感兴趣的特定文件描述符，注册的描述符集合称为epoll集合；

epoll_wait监听IO事件；

2：水平触发和边沿触发

EPOLL事件分发接口有两种工作方式：边沿触发(edge-triggered, ET)和水平触发(level-triggered,LT)。边沿触发模式是epoll的高效工作模式。

水平触发是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。

两种方式的不同可以通过下面的示例说明：

1：rfd是管道读一端的描述符，并且在epoll实例上进行了注册

2：管道另一端写入了2KB的数据

3：调用epoll_wait返回，rfd成为可读描述符

4：从rfd中读取1KB的数据

5：调用epoll_wait

如果rfd在注册到epoll实例时使用了EPOLLET标志，也就是边沿触发，则尽管在缓冲区中依然有数据可读，第5步的epoll_wait调用还是会阻塞，同时管道的另一端有可能在等待发送数据的回应。

原因在于，边沿触发模式，只有在监控的文件描述符状态发生变化的时候，才会触发事件。所以，第5步的epoll_wait有可能一直阻塞下去。上面的示例，第2步的数据写入导致了rfd上事件的产生，并且在第3步中对事件进行了触发。因第4步的读操作没有完全消费掉缓冲区中的数据，所以，第5步的epoll_wait会永远阻塞下去。

对于监听可读事件时,如果是socket是监听socket,那么当有新的主动连接到来为状态发生变化；对一般的socket而言,协议栈中相应的缓冲区有新的数据为状态发生变化。但是,如果在一个时间同时接收了N个连接(N>1),但是监听socket只accept了一个连接,那么其它未
accept的连接将不会在ET模式下给监听socket发出通知,此时状态不发生变化；对于一般的socket,如果对应的缓冲区本身已经有了N字节的数据,而只取出了小于N字节的数据,那么残存的数据不会造成状态发生变化。

仅当对方的动作(发出数据,关闭连接等)造成的事件才能导致状态发生变化,而本方协议栈中已经处理的事件(包括接收了对方的数据,接收了对方的主动连接请求)并不是造成状态发生变化的必要条件,状态变化一定是对方造成的。

使用边沿触发模式的epoll接口，建议是：将文件描述符置为非阻塞；只有在read或write返回EAGAIN后才继续等待事件。

即使在边沿触发模式下，如果收到了多次数据，那么事件也会产生多次。调用者可以指定EPOLLONESHOT标志，使得epoll在接收到一个事件之后，便不再监听相应的文件描述符。如果使用了该标志，则需要调用者用EPOLL_CTL_MOD，调用epoll_ctl，将该文件描述符重新置为监听。

3：/proc 接口限制

下面的接口可用来限制内核中epoll使用的内存总量：

/proc/sys/fs/epoll/max_user_watches(since Linux 2.6.28)

该接口限定了，每个实际用户ID，可以在所有epoll实例上注册的描述符总数。每个注册的描述符，在32位系统上大约耗费90字节，在64位系统上大约耗费160字节。

4：注意

如果在同一个epoll实例上，注册同一个描述符两次的话，则会返回EEXIST错误。

然而，可以向同一个epoll实例添加重复的描述符(dup, dup2)，当重复的描述符注册不同的事件时，使用这种技巧可以用来过滤事件。

如果向两个epoll实例注册了相同的描述符，那么事件触发时，会通知到所有的epoll实例，但是这么做时，一定要小心。

epoll实例的描述符本身，也可以使用poll/epoll/select进行监听，如果该epoll实例正在等待事件，则该epoll实例就是可读的。

如果试图将epoll实例描述符注册到自己的epoll实例上，那么epoll_ctl会返回EINVAL错误。

尽管可以通过UNIX域套接字来传递epoll文件描述符，但是这样做是没有意义的，因为接收进程没有该epoll实例的描述符集合的副本。

关闭一个描述符，会导致该描述符从所有epoll集合中自动被移除。但前提是该描述符没有通过dup等函数进行过复制。一个描述符，在通过dup、dup2、fcntl的F_DUPFD，或者fork之后，会产生一个新的重复描述符，指向相同的文件表。因此，只有当引用同一文件表的所有重复描述符都关闭之后(引用计数为0)，该描述符才会从epoll集合中删除。（可以使用EPOLL_CTL_DEL调用epoll_ctl来明确删除epoll集合中的该描述符）

这意味着，即使epoll集合中的某个描述符被关闭了，但是只要该描述符有打开的重复描述符，那该描述符上的事件，依然会被报告。

如果在epoll_wait调用时，发生了多个事件，则这些事件会合在一起进行报告。

在使用边沿触发时，是否需要持续调用read/write，直到它们返回EAGAIN，这取决于描述符类型，如果描述符是packet/token-oriented类型的，比如UDP数据报，或者canonical模式下的终端，则探测IO读写空间耗尽唯一方法就是持续调用read/write直到返回EAGAIN。

对于流式文件，比如管道、FIFO、流套接字等，则探测IO读写空间耗尽，还可以通过检测read/write返回值进行判断。比如，若调用read请求一定数量的数据，但是read返回值小于该请求数，则可以断定该描述符的IO读空间已经耗尽了。这种情形同样类似于write。

二：epoll系统调用

1：epoll_create、epoll_create1

#include<sys/epoll.h>
 
int epoll_create(int size);
int epoll_create1(int flags);

epoll_create创建一个epoll实例。size参数，自Linux2.6.8开始就被忽略了，但是它的值必须大于0。

epoll_create返回epoll实例的文件描述符，该描述符用于后续的epoll接口调用。当不在需要时，该描述符需要用close关闭。如果一个epoll实例的所有描述符都关闭了，则内核会销毁该实例，并释放相关资源。

epoll_create1，如果flags参数为0，则除了省略了size参数之外，它与epoll_create是相同的。如果flags参数不为0，则目前它只能是EPOLL_CLOEXEC，用于设置该描述符的close-on-exec(FD_CLOEXEC)标志。

这两个系统调用，成功时返回非负的文件描述符，失败时返回-1.

epoll_create是在2.6内核版本中引入，在glibc2.3.2开始支持；epoll_create1是在2.6.27内核版本中引入，在glibc2.9开始支持。

最初的epoll_create实现中，size参数告诉内核，调用者期望添加到epoll实例中的文件描述符数量。内核使用该信息作为初始分配内部数据结构空间大小的“提示”（如果调用者的使用超过了size，则内核会在必要的情况下分配更多的空间）。目前，这种“提示”已经不再需要了，内核动态的改变数据结构的大小，但是为了保证向后兼容性（新的epoll应用运行于旧的内核上），size参数还是要大于0。

2：epoll_ctl

#include<sys/epoll.h>
 
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

该系统调用控制在epoll实例epfd上的执行动作。在epoll实例上注册、注销、更改文件描述符。

该调用会在描述符fd上执行op操作，op的值可以有：

EPOLL_CTL_ADD，在epoll实例epfd上注册文件描述符fd，并将事件event关联到fd。

EPOLL_CTL_MOD，更改fd上关联的事件为event

EPOLL_CTL_DEL，在epoll实例epfd上，删除（注销）描述符fd。event参数被忽略，可以为NULL（在2.6.9之前，即使event参数被忽略，它也不能为NULL。自2.6.9起，操作EPOLL_CTL_DEL上，event才可以为NULL。如果应用程序需要在2.6.9之前的内核上运行，则需要指定非NULL的event）。

event参数，描述了关联到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 */
};

成员data字段由用户使用。监听事件触发后，data会被返回给用户。通常将event.data.fd设定为fd，这样就可以知道哪个文件描述符触发了事件。ptr成员可用来指定与fd相关的用户数据，但因为data是个union，所以，不能同时使用ptr和fd，因此，可以使用其他手段使得文件描述符和用户数据关联起来，比如放弃使用fd，而在ptr指向的用户数据中包含fd。

成员events是由下列值组成的位数组：

EPOLLIN，文件可读；

EPOLLOUT，文件可写；

EPOLLRDHUP (since Linux 2.6.17)，流式套接字，对端关闭了连接，或者半关闭了写操作。该标志，在边沿触发模式下检测对端关闭时，是很有用的；

EPOLLPRI，读操作上有紧急数据；

EPOLLERR，文件描述符上发生了错误。epoll_wait始终监听该事件，无需再events上设置；

EPOLLHUP，文件描述符上发生了Hang up。epoll_wait始终监听该事件，无需再events上设置；

EPOLLET，置文件描述符为边沿触发模式，epoll上默认的行为模式是水平触发模式；

EPOLLONESHOT (since Linux 2.6.2)，置文件描述符为一次性的(one-shot)。这意味着，当该文件上通过epoll_wait触发了一个事件之后，该文件描述符就被内部disable了，在epoll实例上不再报告该文件描述符上的事件了。用户必须用EPOLL_CTL_MOD调用epoll_ctl，以新的事件掩码再次注册该描述符。

epoll_ctl成功时返回0，失败返回-1.

3：epoll_wait

#include <sys/epoll.h>
 
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_wait系统调用在epoll实例epfd上等待事件的发生。成功返回时，events指向的内存空间，会记录触发的事件。maxevents告知内核events的大小。epoll_wait的返回值最大为maxevents, maxevents参数必须大于0.

当调用返回时，如果检测到事件，就将所有就绪的事件从内核事件表中复制到events指向的数组中。这个数组只用于输出epoll_wait检测到的就绪事件，而不像select和poll的数组参数那样，即用于传入用户注册的事件，又用于输出检测到的事件。

timeout参数指定epoll_wait的阻塞时间，单位为毫秒。epoll_wait会一直阻塞，直到：

某个文件描述符上触发了一个事件；

epoll_wait调用被信号中断；

超时时间到；

注意，timeout在内部会向上取整到系统时钟粒度，而且由于内核调度的原因，阻塞时间会有少量的延长。如果timeout为-1，意味着epoll_wait会一直阻塞；如果timeout为0，则即使没有事件发生，epoll_wait也会立即返回。

结构体epoll_event的定义见上，epoll_wait返回时，该结构中的data成员，与调用epoll_ctl（EPOLL_CTL_ADD, EPOLL_CTL_MOD）时的data一样。events成员包含触发的事件掩码。

epoll_wait和epoll_pwait之间的关系，类似于select和pselect之间的关系：epoll_pwait可以使应用程序安全的等待信号的发生。下面的语句：

ready = epoll_pwait(epfd, &events, maxevents, timeout, &sigmask);

等价于下列语句的原子执行：

sigset_t origmask;
 
sigprocmask(SIG_SETMASK, &sigmask, &origmask);
ready = epoll_wait(epfd, &events, maxevents, timeout);
sigprocmask(SIG_SETMASK, &origmask, NULL);

如果将sigmask置为NULL，则epoll_pwait等价于epoll_wait。

epoll_wait成功时返回准备好的文件描述符数，如果超时时间到了，还没有准备好的文件描述符，则返回0.出错时返回-1.

epoll_wait自2.6内核引入，glibc2.3.2开始支持；epoll_pwait自2.6.19内核引入，glibc2.6开始支持.

注意，如果某个线程阻塞于epoll_wait时，另一个线程向相同的epoll实例上添加了新的文件描述符，而且该描述符上的事件触发，则会导致原来阻塞于epoll_wait上的线程停止阻塞。

在select系统调用中，如果select上监听的描述符，在其他线程上被关闭了，则这种行为是未定义的。某些UNIX系统上，select会停止阻塞直接返回，并且将该描述符视为准备好的（接下来的IO操作会发生错误）。在Linux（以及其他系统）上，在其他线程上关闭该描述符对select无影响，epoll上的处理方式也一样。

在2.6.37之前，如果timeout参数大于(LONG_MAX/HZ)毫秒的话，则会被视为-1，也就意味着永远等待。所以，如果某系统上sizeof(long)等于4，HZ等于1000，则如果timeouts大于35.79的话，就会给视为无限等待。((2^31 – 1) /1000/1000/60
== 35.79)

三：示例

1：对于采用LT工作模式的文件描述符，当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序可以不立即处理该事件。当应用程序下一次调用epoll_wait时，epoll_wait还会再次向应用程序通告此事件，直到该事件被处理。也就是说只要还有没有处理的事件就会一直通知。

而对于采用 ET工作模式的文件描述符，当epoll_wait检测到其上有事件发生并将此事件通知应用程序后，应用程序必须立即处理该事件，因为后续的epoll_wait调用将不再向应用程序通知这一事件。可见，ET模式在很大程度上降低了同一个epoll事件被重复触发的次数，因此效率要比LT模式高。边沿触发需要一个不同的方式来写程序，通常利用非阻塞IO。并需要仔细检查EAGAIN。

下面的代码体现了LT和ET在工作方式上的差异。

#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;
}
 
void addfd(int epollfd,  int fd,  bool enable_et)
{
    struct 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);
}
 
void lt(struct 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 )
        {
            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" );
        }
    }
}
 
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 );
        }
        else if (events[i].events & EPOLLIN)
        {
            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 = bind( listenfd, ( struct sockaddr* )&address, sizeof( address ) );
    assert( ret != -1 );
 
    ret = listen( listenfd, 5 );
    assert( ret != -1 );
 
    struct epoll_event events[ MAX_EVENT_NUMBER ];
    int epollfd = epoll_create( 5 );
    assert( epollfd != -1 );
    addfd( epollfd, listenfd, false);
 
    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);
        //et( events, ret, epollfd, listenfd);
    }
 
    close( listenfd );
    return 0;
}

2：即使使用ET模式，一个socket上的某个事件还是可能被触发多次。这在并发程序中就会引起一个问题。比如一个线程(或进程，下同)在读取完某个socket的数据后开始处理这此数据，而在数据的处理过程中该socket上又有新数据可读，此时另外一个线程被唤醒来读取这些新的数据（参见下面的代码）。于是就出现了两个线程同时操作一个socket的局面。这当然不是找们期望的。我们期望的是一个socket连接在任一时刻都只被一个线程处理。这一点可以使用epoll的EPOLLONESHOT事件实现。

对于注册了EPOLLONESHOT事件的文件描述符，操作系统最多触发其上注册的一个可读、可写或者异常事件，且只触发一次，除非我们使用epoll_ctl函数重置该文件描述符上注册的EPOLLONESHOT事件。这样，当一个线程在处理某个socket时.其他线程是不可能有机会操作该socket的。但反过来思考，注册了EPOLLONESHOT事件的socket一旦被某个线程处理完毕，该线程就应该立即重置这个socket上的EPOLLONESHOT事件，以确保这个socket下一次可读时，其EPOLLIN事件能被触发，进而让其他工作线程有机会继续处理这个socket。

下面的代码展示EPOLLONESHOT事件的使用：

#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;
}
 
void addfd( int epollfd, int fd, bool oneshot )
{
    struct 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 );
}
 
void reset_oneshot( int epollfd, int fd )
{
    struct 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 );
    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" );
                break;
            }
        }
        else
        {
            printf( "get content: %s\n", buf );
            sleep( 5 );//休眠5s，模拟数据处理过程
        }
    }
    printf( "end thread receiving 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 );
    addfd( epollfd, listenfd, false );//listenfd不能注册EPOLLONESHOT事件，否则应用程序只能处理一个客户连接，后续的客户连接请求将不再出发listenfd上的EPOLLIN事件。
 
    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 );
                while((connfd = accept( listenfd, ( struct sockaddr* )&client_address, &client_addrlength )) > 0)
                {
                    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;
                pthread_create( &thread, NULL, worker, ( void* )&fds_for_new_worker );
            }
            else
            {
                printf( "something else happened \n" );
            }
        }
    }
 
    close( listenfd );
    return 0;
}

从工作线程函数worker来看，如果一个工作线程处理完某个socket上的一次请求（用休眠5s来模拟这个过程）之后，又接收到该socket上新的客户请求，则该线程将继续为这个socket服务。并且因为该socket上注册了EPOLLONESHOT事件，其他线程没有机会接触这个socket，如果工作线程等待5s后仍然没收到该socket上的下一批客户数据，则它将放弃为该socket服务。同时，它调用reset_oneshot函数来重置该socket的注册事件，这将使epoll有机会再次检测到该socket的EPOLLIN事件，进而使得其他线程有机会为该socket服务。

由此看来，尽管一个socket在不同时间能被不同的线程处理，但同一时刻肯定只有一个线程在为它服务。这就保证了连接的完整性，从而避免了很多可能的竟态条件。

参考：

http://blog.csdn.net/Al_xin/article/details/39037037

man手册