epoll簡介

epoll 是Linux內核中的一種可擴展IO事件處理機制，最早在 Linux 2.5.44內核中引入，可被用于代替POSIX select 和 poll 系統調用，并且在具有大量應用程序請求時能夠獲得較好的性能（ 此時被監視的文件描述符數目非常大，與舊的 select 和 poll 系統調用完成操作所需 O(n) 不同， epoll能在O(1)時間內完成操作，所以性能相當高），epoll 與 FreeBSD的kqueue類似，都向用戶空間提供了自己的文件描述符來進行操作。

int epoll_create(int size);

創建一個epoll的句柄，size用來告訴內核需要監聽的數目一共有多大。當創建好epoll句柄后，它就是會占用一個fd值，在linux下如果查看/proc/進程id/fd/，是能夠看到這個fd的，所以在使用完epoll后，必須調用close() 關閉，否則可能導致fd被耗盡。

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

epoll的事件注冊函數，第一個參數是 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隊列里。

當對方關閉連接(FIN), EPOLLERR，都可以認為是一種EPOLLIN事件，在read的時候分別有0，-1兩個返回值。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

參數events用來從內核得到事件的集合，maxevents 告之內核這個events有多大，這個 maxevents 的值不能大于創建 epoll_create() 時的size，參數 timeout 是超時時間（毫秒，0會立即返回，-1將不確定，也有說法說是永久阻塞）。該函數返回需要處理的事件數目，如返回0表示已超時。

EPOLL事件有兩種模型 Level Triggered (LT) 和 Edge Triggered (ET)：

LT(level triggered，水平觸發模式)是缺省的工作方式，并且同時支持 block 和 non-block socket。在這種做法中，內核告訴你一個文件描述符是否就緒了，然后你可以對這個就緒的fd進行IO操作。如果你不作任何操作，內核還是會繼續通知你的，所以，這種模式編程出錯誤可能性要小一點。

ET(edge-triggered，邊緣觸發模式)是高速工作方式，只支持no-block socket。在這種模式下，當描述符從未就緒變為就緒時，內核通過epoll告訴你。然后它會假設你知道文件描述符已經就緒，并且不會再為那個文件描述符發送更多的就緒通知，等到下次有新的數據進來的時候才會再次出發就緒事件。

epoll 例子

我們將實現一個簡單的TCP 服務器，該迷你服務器將會在標準輸出上打印處客戶端發送的數據，首先我們創建并綁定一個 TCP 套接字：

static int
create_and_bind (char *port)
{
struct addrinfo hints;
struct addrinfo *result, *rp;
int s, sfd;

memset (&hints, 0, sizeof (struct addrinfo));
hints.ai_family = AF_UNSPEC; /* Return IPv4 and IPv6 choices */
hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
hints.ai_flags = AI_PASSIVE; /* All interfaces */

s = getaddrinfo (NULL, port, &hints, &result);
if (s != 0)
{
fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
return -1;
}

for (rp = result; rp != NULL; rp = rp->ai_next)
{
sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
if (sfd == -1)
continue;
s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
if (s == 0)
{
/* We managed to bind successfully! */
break;
}

close (sfd);
}
if (rp == NULL)
{
fprintf (stderr, "Could not bind\n");
return -1;
}
freeaddrinfo (result);
return sfd;
}

create_and_bind() 包含了如何創建 IPv4 和 IPv6 套接字的代碼塊，它接受一字符串作為端口參數，并在 result 中返回一個 addrinfo 結構，

struct addrinfo
{
int ai_flags;
int ai_family;
int ai_socktype;
int ai_protocol;
size_t ai_addrlen;
struct sockaddr *ai_addr;
char *ai_canonname;
struct addrinfo *ai_next;
};

如果函數成功則返回套接字，如果失敗，則返回 -1，

?

下面，我們將一個套接字設置為非阻塞形式，函數如下：

static int
make_socket_non_blocking (int sfd)
{
int flags, s;

flags = fcntl (sfd, F_GETFL, 0);
if (flags == -1)
{
perror ("fcntl");
return -1;
}

flags |= O_NONBLOCK;
s = fcntl (sfd, F_SETFL, flags);
if (s == -1)
{
perror ("fcntl");
return -1;
}

return 0;
}

接下來，便是主函數代碼，主要用于事件循環：

#define MAXEVENTS 64

int
main (int argc, char *argv[])
{
int sfd, s;
int efd;
struct epoll_event event;
struct epoll_event *events;

if (argc != 2)
{
fprintf (stderr, "Usage: %s [port]\n", argv[0]);
exit (EXIT_FAILURE);
}

sfd = create_and_bind (argv[1]);
if (sfd == -1)
abort ();

s = make_socket_non_blocking (sfd);
if (s == -1)
abort ();

s = listen (sfd, SOMAXCONN);
if (s == -1)
{
perror ("listen");
abort ();
}

efd = epoll_create1 (0);
if (efd == -1)
{
perror ("epoll_create");
abort ();
}

event.data.fd = sfd;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
if (s == -1)
{
perror ("epoll_ctl");
abort ();
}

/* Buffer where events are returned */
events = calloc (MAXEVENTS, sizeof event);

/* The event loop */
while (1)
{
int n, i;

n = epoll_wait (efd, events, MAXEVENTS, -1);
for (i = 0; i < n; i++)
{
if ((events[i].events & EPOLLERR) ||
(events[i].events & EPOLLHUP) ||
(!(events[i].events & EPOLLIN)))
{
/* An error has occured on this fd, or the socket is not
ready for reading (why were we notified then?) */
fprintf (stderr, "epoll error\n");
close (events[i].data.fd);
continue;
}

else if (sfd == events[i].data.fd)
{
/* We have a notification on the listening socket, which
means one or more incoming connections. */
while (1)
{
struct sockaddr in_addr;
socklen_t in_len;
int infd;
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

in_len = sizeof in_addr;
infd = accept (sfd, &in_addr, &in_len);
if (infd == -1)
{
if ((errno == EAGAIN) ||
(errno == EWOULDBLOCK))
{
/* We have processed all incoming
connections. */
break;
}
else
{
perror ("accept");
break;
}
}

s = getnameinfo (&in_addr, in_len,
hbuf, sizeof hbuf,
sbuf, sizeof sbuf,
NI_NUMERICHOST | NI_NUMERICSERV);
if (s == 0)
{
printf("Accepted connection on descriptor %d "
"(host=%s, port=%s)\n", infd, hbuf, sbuf);
}

/* Make the incoming socket non-blocking and add it to the
list of fds to monitor. */
s = make_socket_non_blocking (infd);
if (s == -1)
abort ();

event.data.fd = infd;
event.events = EPOLLIN | EPOLLET;
s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
if (s == -1)
{
perror ("epoll_ctl");
abort ();
}
}
continue;
}
else
{
/* We have data on the fd waiting to be read. Read and
display it. We must read whatever data is available
completely, as we are running in edge-triggered mode
and won't get a notification again for the same
data. */
int done = 0;

while (1)
{
ssize_t count;
char buf[512];

count = read (events[i].data.fd, buf, sizeof buf);
if (count == -1)
{
/* If errno == EAGAIN, that means we have read all
data. So go back to the main loop. */
if (errno != EAGAIN)
{
perror ("read");
done = 1;
}
break;
}
else if (count == 0)
{
/* End of file. The remote has closed the
connection. */
done = 1;
break;
}

/* Write the buffer to standard output */
s = write (1, buf, count);
if (s == -1)
{
perror ("write");
abort ();
}
}

if (done)
{
printf ("Closed connection on descriptor %d\n",
events[i].data.fd);

/* Closing the descriptor will make epoll remove it
from the set of descriptors which are monitored. */
close (events[i].data.fd);
}
}
}
}

free (events);

close (sfd);

return EXIT_SUCCESS;
}

main() 首先調用 create_and_bind() 建立套接字，然后將其設置為非阻塞的，再調用 listen(2)。之后創建一個epoll 實例 efd（文件描述符），并將其加入到sfd的監聽套接字中以邊沿觸發方式等待事件輸入。

外層的 while 循環是主事件循環，它調用了 epoll_wait(2)，此時線程仍然被阻塞等待事件，當事件可用時，epoll_wait(2) 將會在events參數中返回可用事件。

epoll 實例 efd 在每次事件到來并需要添加新的監聽時就會得到更新，并刪除死亡的鏈接。

當事件可用時，可能有一下三種類型：

• Errors: 當錯誤情況出現時，或者不是與讀取數據相關的事件通告，我們只是關閉相關的描述符，關閉該描述符會自動的將其從被epoll 實例 efd 監聽的的集合中刪除。
• New connections: 當監聽的文件描述符 sfd 可讀時，此時會有一個或多個新的連接到來，當新連接到來時，accept(2) 該連接，并打印一條信息，將其設置為非阻塞的并把它加入到被 epoll 實例監聽的集合中。
• Client data: 當數據在客戶端描述符可用時，我們使用 read(2) 在一個內部循環中每次讀取512 字節數據。由于我們必須讀取所有的可用數據，此時我們并不能獲取更多的事件，因為描述符是以邊沿觸發監聽的，讀取的數據被寫到 stdout (fd=1) (write(2))。如果 read(2) 返回 0，意味著到了文件末尾EOF，我們可以關閉客戶端連接，如果返回? -1， errno 會被設置成 EAGAIN, 這意味著所有的數據已經被讀取，可以返回主循環了。

（全文完）

?參考資料：

http://en.wikipedia.org/wiki/Epoll

https://banu.com/blog/2/how-to-use-epoll-a-complete-example-in-c/

http://blog.csdn.net/ljx0305/article/details/4065058

http://kovyrin.net/2006/04/13/epoll-asynchronous-network-programming/

總結

以上是生活随笔為你收集整理的epoll 使用详解的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。