1. epoll 原理
假设有 100 万用户同时与一个进程保持着 TCP 连接，而每一时刻只有几十个或几百个 TCP 连接时活跃的（接收到 TCP
包），也就是说，在每一时刻，进程只需要处理这 100 万连接中的一小部分连接。select 和 poll 的做法是：进程每次收集事件的连接（其实这 100 万连接中的大部分都是没有事件发生的）都把这 100 万连
接的套接字传给操作系统（这首先就是用户态内存到内核态内存的大量复制），而由操作系统内核寻找这些连接上有没有未 处理的事件，将会是巨大的资源浪费，因此 select 和 poll 最多只能处理几千个并发连接。而 epoll 则是在 Linux 内核中申请了一个简易的文件系统，把原先的一个 select 或者 poll 调用分成了 3 个部分：
- 调用 epoll_create 建立 1 个 epoll 对象（在 epoll 文件系统中给这个句柄分配资源）；
- 调用 epoll_ctl 向 epoll 对象中添加这 100 万个连接的套接字；
- 调用 epoll_wait 收集发生事件的连接。
Linux 2.6.35内核对 epoll 的实现
当某一个进程调用 epoll_create 方法时，Linux 内核会创建一个 eventpoll 结构体：
struct eventpoll { ... /* 红黑树的根节点，这棵树中存储着所有添加到 epoll 中的事件，也就是这个 epoll 监控的事件 */ struct rb_root rbr; /* 双向链表 rdllist 保存着将要通过 epoll_wait 返回给用户的、满足条件的事件 */ struct list_head rdllist;}; 每一个 epoll 对象都有一个独立的 eventpoll 结构体，这个结构体会在内核空间中创造独立的内存，用于存储使用
epoll_ctl 方法向 epoll 对象中添加进来的事件。这些事件都会挂到 rbr 红黑树中，这样，重复添加的事件就可以通过红黑 树而高效地识别出来。所有添加到 epoll 中的事件都会与设备（如网卡）驱动程序建立回调关系，即相应的事件发生时会调用 ep_poll_callback 回调
方法，它会把这样的事件放到上面的 rdllist 双向链表中。在 epoll 中，对于每一个事件都会建立一个 epitem 结构体：
struct epitem { ... /* 红黑树节点 */ struct rb_node rbn; /* 双向链表节点 */ struct list_head rdllink; /* 事件句柄等信息 */ struct epoll_filefd ffd; /* 指向所属的 eventpoll 对象 */ struct eventpoll *ep; /* 期待的事件类型 */ struct epoll_event event; ...}; 这里包含每一个事件对应着的信息。
当调用 epoll_wait 检查是否有事件的连接时，只是检查 eventpoll 对象中的 rdllist 双向链表是否有 epitem 元素，如果 rdllist 链表不为空，则把这里的事件复制到用户态内存中，同时将事件数量返回给用户。2. epoll 的使用
2.1 epoll 的接口
2.1.1 epoll_create()
int epoll_create(int size);
系统调用 epoll_create() 创建一个 epoll 的句柄，之后 epoll 的使用都将依靠这个句柄来标识。参数 size 是告知 epoll 所
要处理的大致事件数目。不再使用 epoll 时，必须调用 close 关闭这个句柄。2.1.2 epoll_ctl()
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);
epoll_ctl 向 epoll 对象中添加、修改或者删除感兴趣的事件，返回 0 表示成功，否则返回 -1，此时需要根据 errno 错误码
判断错误类型。- epfd：是 epoll_create() 返回的句柄；
- op：表示动作，可取的值有：
- EPOLL_CTL_ADD: 添加新的事件到 epoll 中
- EPOLL_CTL_MOD: 修改 epoll 中的事件
- EPOLL_CTL_DEL：删除 epoll 中的事件
- fd: 需要监听的描述符；
- event: 是 epoll_event 结构体类型，用于告诉内核需要监听什么事件。epoll_event 的定义：
struct epoll_event { __uint32_t events; epoll_data_t data;}; - events：的取值有
- EPOLLIN: 表示对应的连接上有数据可读（TCP 连接的远端主动关闭连接，也相当于可读事件，因为需要处理发送来的 FIN）
- EPOLLOUT: 表示对应的连接上可以写入数据发送（主动向上游服务器发起非阻塞的 TCP 连接，连接建立成功的事件相当于可写事件）
- EPOLLRDHUP：表示 TCP 连接的远端关闭或半关闭连接
- EPOLLLPRI：表示对应的连接上有紧急数据需要读
- EPOLLERR: 表示对应的连接发生错误
- EPOLLHUP: 表示对应的连接被挂起
- EPOLLLET: 表示将触发方式设置为边缘触发（ET），系统默认为水平触发(LT)
- EPOLLONESHOT: 表示对这个事件只处理一次，下次需要处理时需重新加入 epoll
- data：是一个 epoll_data 联合，定义如下：
typedef union epoll_data { void *ptr; int fd; uint32_t u32; uint64_t u64;}epoll_data_t; 2.1.3 epoll_wait()
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
收集在 epoll 监控的事件中已经发生的事件，如果 epoll 中没有任何一个事件发生，则最多等待 timeout 毫秒后返回。
epoll_wait 的返回值表示当前发生的事件个数，如果返回 0，则表示本次调用中没有事件发生，如果返回 -1，则表示发生错 误，需要检查 errno 判断错误类型。- epfd：是 epoll_create() 返回的句柄；
- events：是分配好的 epoll_event 结构体数组，epoll 将会把发生的事件复制到 events 数组中（events 不可以是空指针， 内核只负责把数据复制到这个 events 数组中，不会去帮助我们在用户态中分配内存）
- maxevents：表示本次可以返回的最大事件数目，通常 maxevents 参数与预分配的 events 数组的大小是相等的；
- timeout：表示在没有检测到事件发生时最多等待的时间（单位为毫秒），如果 timeout 为 0，则表示 epoll_wait 在 rdllist 链表为空时，立刻返回，不会等待。
2.2 epoll 的工作模式
epoll 有两种工作模式：LT（水平触发）模式和 ET（边缘触发）模式。
默认情况下，epoll 采用 LT 模式工作，这时可以处理阻塞和非阻塞套接字。ET 模式的效率要比 LT 模式高，它只支持非阻塞
字。ET 和 LT 模式的区别在于，当一个新的事件到来时，ET 模式下当然可以从 epoll_wait调用中获取这个事件，可是如果这 次没有把这个事件对应的套接字缓冲区处理完，在这个套接字没有新的事件再次到来时，在 ET 模式下是无法再次从 epoll_wait 调用中获取这个事件的；而 LT 模式则相反，只要一个事件对应的套接字缓冲区还有数据，就总能从 epoll_wait 中获取这个事件。因此，LT 模式相对简单，而在 ET 模式下事件发生时，如果没有彻底地将缓冲区数据处理完，则会导致缓冲 区中的用户请求得不到响应。默认情况下，Nginx 是通过 ET 模式使用 epoll 的。3. ngx_epoll_module 模块
3.1 配置项
static ngx_command_t ngx_epoll_commands[] = { /* 在调用 epoll_wait 时，将由第 2 和第 3 个参数告诉 Linux 内核一次最多可返回多少个事件。这个配置项 * 表示调用一次 epoll_wait 时最多可以返回的事件数，当然，它也会预分配那么多 epoll_event 结构体用于 * 存储事件 */ { ngx_string("epoll_events"), NGX_EVENT_CONF|NGX_CONF_TAKE1, ngx_conf_set_num_slot, 0, offsetof(ngx_epoll_conf_t, events), NULL }, /* 指明在开启异步 I/O 且使用 io_setup 系统调用初始化异步 I/O 上下文环境时，初始分配的异步 I/O * 事件个数 */ { ngx_string("worker_aio_requests"), NGX_EVENT_CONF|NGX_CONF_TAKE1, ngx_conf_set_num_slot, 0, offsetof(ngx_epoll_conf_t, aio_requests), NULL }, ngx_null_command}; 存储配置项的配置结构体：
typedef struct { ngx_uint_t events; ngx_uint_t aio_requests;} ngx_epoll_conf_t; 3.2 上下文结构体：ngx_epoll_module_ctx
static ngx_event_module_t ngx_epoll_module_ctx = { &epoll_name, ngx_epoll_create_conf, /* create configuration */ ngx_epoll_init_conf, /* init configuration */ { ngx_epoll_add_event, /* add an event */ ngx_epoll_del_event, /* delete an event */ ngx_epoll_add_event, /* enable an event */ ngx_epoll_del_event, /* disable an event */ ngx_epoll_add_connection, /* add an connection */ ngx_epoll_del_connection, /* delete an connection */#if (NGX_HAVE_EVENTFD) ngx_epoll_notify, /* trigger a notify */#else NULL, /* trigger a notify */#endif ngx_epoll_process_events, /* process the events */ ngx_epoll_init, /* init the events */ ngx_epoll_done, /* done the events */ }}; 3.2.1 ngx_epoll_init
static ngx_int_t ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer){ ngx_epoll_conf_t *epcf; /* 获取配置项结构体 */ epcf = ngx_event_get_conf(cycle->conf_ctx, ngx_epoll_module); if (ep == -1) { /* 创建一个 epoll 句柄 */ ep = epoll_create(cycle->connection_n / 2); if (ep == -1) { ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno, "epoll_create() failed"); return NGX_ERROR; }#if (NGX_HAVE_EVENTFD) if (ngx_epoll_notify_init(cycle->log) != NGX_OK) { ngx_epoll_module_ctx.actions.notify = NULL; }#endif#if (NGX_HAVE_FILE_AIO) ngx_epoll_aio_init(cycle, epcf);#endif#if (NGX_HAVE_EPOLLRDHUP) ngx_epoll_test_rdhup(cycle);#endif } if (nevents < epcf->events) { if (event_list) { ngx_free(event_list); } /* 创建 event_list 数组，用于进行 epoll_wait 调用时传递内核态的事件 */ event_list = ngx_alloc(sizeof(struct epoll_event) * epcf->events, cycle->log); if (event_list == NULL) { return NGX_ERROR; } } /* 将配置项epoll_events的参数赋给nevents */ nevents = epcf->events; /* 指明读写I/O的方法 */ ngx_io = ngx_os_io; /* 一旦设定Nginx使用某个事件处理模块，经过事件处理模块的初始化函数后，就把全局变量 * ngx_event_actions指向了该模块的封装 */ ngx_event_actions = ngx_epoll_module_ctx.actions;#if (NGX_HAVE_CLEAR_EVENT) /* 默认是采用ET模式来使用epoll的，NGX_USE_CLEAR_EVENT宏实际上就是在告诉Nginx使用ET模式 */ ngx_event_flags = NGX_USE_CLEAR_EVENT#else ngx_event_flags = NGX_USE_LEVEL_EVENT#endif |NGX_USE_GREEDY_EVENT |NGX_USE_EPOLL_EVENT; return NGX_OK;} 3.2.2 ngx_epoll_add_event
static ngx_int_t ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags){ int op; uint32_t events, prev; ngx_event_t *e; ngx_connection_t *c; struct epoll_event ee; /* 每个事件的 data 成员都存放着其对应的 ngx_connection_t 连接 */ c = ev->data; /* 下面会根据event参数确定当前事件时读事件还是写事件， * 这会决定events是加上EPOLLIN标志还是EPOLLOUT标志位 */ events = (uint32_t) event; if (event == NGX_READ_EVENT) { e = c->write; prev = EPOLLOUT;#if (NGX_READ_EVENT != EPOLLIN|EPOLLRDHUP) events = EPOLLIN|EPOLLRDHUP;#endif } else { e = c->read; prev = EPOLLIN|EPOLLRDHUP;#if (NGX_WRITE_EVENT != EPOLLOUT) events = EPOLLOUT;#endif } /* 根据active标志位确定是否为活跃事件，以决定到底是修改还是添加事件 */ if (e->active) { op = EPOLL_CTL_MOD; events |= prev; } else { op = EPOLL_CTL_ADD; }#if (NGX_HAVE_EPOLLEXCLUSIVE && NGX_HAVE_EPOLLRDHUP) if (flags & NGX_EXCLUSIVE_EVENT) { events &= ~EPOLLRDHUP; }#endif /* 加入flags参数到events标志位中 */ ee.events = events | (uint32_t) flags; /* ptr成员存储的是ngx_connection_t连接 */ ee.data.ptr = (void *) ((uintptr_t) c | ev->instance); ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0, "epoll add event: fd:%d op:%d ev:%08XD", c->fd, op, ee.events); /* 调用 epoll_ctl 方法向 epoll 中添加事件或者在 epoll 中修改事件 */ if (epoll_ctl(ep, op, c->fd, &ee) == -1) { ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno, "epoll_ctl(%d, %d) failed", op, c->fd); return NGX_ERROR; } /* 将事件的 active 标志位置为 1，表示当前事件是活跃的 */ ev->active = 1;#if 0 ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;#endif return NGX_OK;} 3.2.3 ngx_epoll_process_events
static ngx_int_t ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags){ int events; uint32_t revents; ngx_int_t instance, i; ngx_uint_t level; ngx_err_t err; ngx_event_t *rev, *wev; ngx_queue_t *queue; ngx_connection_t *c; /* NGX_TIMER_INFINITE == INFTIM */ ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "epoll timer: %M", timer); /* 调用 epoll_wait 获取事件。注意，timer 参数是在 process_events 调用时传入的 */ events = epoll_wait(ep, event_list, (int) nevents, timer); err = (events == -1) ? ngx_errno : 0; /* 判断flags标志位是否指示要更新时间或ngx_event_timer_alarm是否为1 */ if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) { ngx_time_update(); } if (err) { if (err == NGX_EINTR) { if (ngx_event_timer_alarm) { ngx_event_timer_alarm = 0; return NGX_OK; } level = NGX_LOG_INFO; } else { level = NGX_LOG_ALERT; } ngx_log_error(level, cycle->log, err, "epoll_wait() failed"); return NGX_ERROR; } if (events == 0) { if (timer != NGX_TIMER_INFINITE) { return NGX_OK; } ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "epoll_wait() returned no events without timeout"); return NGX_ERROR; } /* 遍历本次 epoll_wait 返回的所有事件 */ for (i = 0; i < events; i++) { c = event_list[i].data.ptr; /* uintptr_t 在 64 位平台上为：typedef unsigned long int upintptr_t; * 在 32 位平台上为：typedef unsigned int uintptr_t; * 该类型主要是为了跨平台，其长度总是所在平台的位数，常用于存放地址. */ /* 将地址的最后一位取出来，用 instance 变量标识 */ instance = (uintptr_t) c & 1; /* 无论是 32 位还是 64 位机器，其地址的最后 1 位肯定是 0，可以用下面这行语句把 * ngx_connection_t 的地址还原到真正的地址值 */ c = (ngx_connection_t *) ((uintptr_t) c & (uintptr_t) ~1); /* 取出读事件 */ rev = c->read; /* 判断这个读事件是否是过期事件 */ if (c->fd == -1 || rev->instance != instance) { /* 当 fd 套接字描述符为 -1 或者 instance 标志位不相等时， * 表示这个事件已经过期了，不用处理 */ /* * the stale event from a file descriptor * that was just closed in this iteration */ ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "epoll: stale event %p", c); continue; } /* 取出事件类型 */ revents = event_list[i].events; ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "epoll: fd:%d ev:%04XD d:%p", c->fd, revents, event_list[i].data.ptr); /* 若事件发生错误或被挂起 */ if (revents & (EPOLLERR|EPOLLHUP)) { ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "epoll_wait() error on fd:%d ev:%04XD", c->fd, revents); /* * if the error events were returned, add EPOLLIN and EPOLLOUT * to handle the events at least in one active handler */ revents |= EPOLLIN|EPOLLOUT; }#if 0 if (revents & ~(EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP)) { ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "strange epoll_wait() events fd:%d ev:%04XD", c->fd, revents); }#endif /* 如果是读事件且该事件是活跃的 */ if ((revents & EPOLLIN) && rev->active) {#if (NGX_HAVE_EPOLLRDHUP) if (revents & EPOLLRDHUP) { rev->pending_eof = 1; } rev->available = 1;#endif rev->ready = 1; /* flags 参数中含有 NGX_POST_EVENTS 表示这批事件要延后处理 */ if (flags & NGX_POST_EVENTS) { /* 如果要在 post 队列中延后处理该事件，首先要判断它是新连接事件还是普通事件， * 以决定把它加入到 ngx_posted_accept_events 队列或者 ngx_posted_events 队列 * 中 */ queue = rev->accept ? &ngx_posted_accept_events : &ngx_posted_events; /* 将这个事件添加到相应的延后执行队列中 */ ngx_post_event(rev, queue); } else { /* 立即调用读事件的回调方法来处理这个事件 */ rev->handler(rev); } } /* 取出写事件 */ wev = c->write; /* 如果写事件且事件是活跃的 */ if ((revents & EPOLLOUT) && wev->active) { /* 检测该事件是否是过期的 */ if (c->fd == -1 || wev->instance != instance) { /* 如果 fd 描述符为 -1 或者 instance 标志位不相等时，表示这个 * 事件是过期的，不用处理 */ /* * the stale event from a file descriptor * that was just closed in this iteration */ ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "epoll: stale event %p", c); continue; } wev->ready = 1;#if (NGX_THREADS) wev->complete = 1;#endif /* 若该事件要延迟处理 */ if (flags & NGX_POST_EVENTS) { /* 将该写事件添加到延迟执行队列中 */ ngx_post_event(wev, &ngx_posted_events); } else { /* 立即调用这个写事件的回调方法来处理这个事件 */ wev->handler(wev); } } } return NGX_OK;} ngx_epoll_process_events 方法会收集当前触发的所有事件，对于不需要加入到 post 队列延后处理的事件，该方法会立即执行
它们的回调方法，这其实是在做分发事件的工作，只是它会在自己的进程中调用这些回调方法而已，因此，每一个回调方法都不能 导致进程休眠或者消耗太多时间，以免 epoll 不能即时地处理其他事件.什么是过期事件？
假设 epoll_wait 一次返回 3 个事件，在第 1 个事件的处理过程中，由于业务的需要，所以关闭了一个连接，而这个连接恰好对
应第 3 个事件。这样的话，在处理到第 3 个事件时，这个事件就已经是过期事件了，一旦处理必然出错。但是单纯把这个连接 的 fd 套接字置为 -1 是不能解决问题的。如下场景：
假设第 3 个事件对应的 ngx_connection_t 连接中的 fd 套接字原先是 50，处理第 1 个事件时把这个连接的套接字关闭了，同 时置为 -1，并且调用 ngx_free_connection 将该连接归还给连接池。在 ngx_epoll_process_events 方法的循环中开始处理第 2 个事件，恰好第 2 个事件是建立新连接事件，调用 ngx_get_connection 从连接池中取出的连接非常可能就是刚刚释放的第 3 个 事件对应的连接。由于套接字 50 刚刚被释放，Linux 内核非常有可能把刚刚释放的套接字 50 又分配给新建立的连接。因此， 在循环中处理第 3 个事件时，这个事件就是过期的了。它对应的事件是关闭的连接，而不是新建立的连接。因此，解决这个问题，依靠于 instance 标志位。当调用 ngx_get_connection 从连接池中获取一个新连接时，instance 标志位
就会置反。这样，当这个 ngx_connection_t 连接重复使用时，它的 instance 标志位一定是不同的。因此，在 ngx_epoll_process_events 方法中一旦判断 instance 发生了变化，就认为是过期事件而不予处理。3.3 模块的定义
ngx_module_t ngx_epoll_module = { NGX_MODULE_V1, &ngx_epoll_module_ctx, /* module context */ ngx_epoll_commands, /* module directives */ NGX_EVENT_MODULE, /* module type */ NULL, /* init master */ NULL, /* init module */ NULL, /* init process */ NULL, /* init thread */ NULL, /* exit thread */ NULL, /* exit process */ NULL, /* exit master */ NGX_MODULE_V1_PADDING};