Linux 網絡編程：select、poll 與 epoll 深度解析 —

一、IO 多路復用：解決并發 IO 的核心技術

在網絡編程中，當需要同時處理大量客戶端連接時，傳統阻塞式 IO 會導致程序卡在單個操作上，造成資源浪費。IO 多路復用技術允許單線程監聽多個文件描述符（FD），當任意 FD 就緒（可讀 / 可寫 / 異常）時，程序能立即響應，是高效處理并發的關鍵。
Linux 提供了三種主流實現：select、poll?和?epoll，其中?epoll?是高并發場景的首選方案。

二、select：經典多路復用接口（適用于小規模并發）

1. 核心原理與數據結構

（1）核心設計思想

select 是 Linux 早期實現的 IO 多路復用接口，通過?位掩碼集合?監聽多個文件描述符（FD）的可讀、可寫或異常事件。其核心是將用戶空間的 FD 集合復制到內核空間，由內核檢測哪些 FD 就緒，最后將就緒狀態返回給用戶空間。

（2）數據結構：`fd_set`?位掩碼

本質：一個固定大小的位掩碼（數組），每一位對應一個 FD。
默認限制：受限于系統宏?FD_SETSIZE（通常為 1024），即最多監聽 1024 個 FD（FD 范圍：0~1023）。

操作函數：

#include <sys/select.h>  
void FD_ZERO(fd_set *set);        // 清空集合（所有位設為 0）  
void FD_SET(int fd, fd_set *set);  // 將 FD 添加到集合（對應位設為 1）  
void FD_CLR(int fd, fd_set *set);  // 將 FD 從集合移除（對應位設為 0）  
int  FD_ISSET(int fd, fd_set *set); // 檢查 FD 是否在集合中（對應位是否為 1）

（3）核心函數：`select`

#include <sys/select.h>  
int select(int maxfd, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

參數	解釋
`maxfd`	監聽的最大 FD 值 + 1（例如 FD 為 3、5，則?`maxfd=6`），確保覆蓋所有監聽的 FD。
`readfds`	可讀事件集合（監聽哪些 FD 有數據可讀）。
`writefds`	可寫事件集合（監聽哪些 FD 可無阻塞寫入，較少使用）。
`exceptfds`	異常事件集合（如帶外數據，通常設為?`NULL`）。
`timeout`	超時時間： -?`NULL`：永久阻塞，直到任意 FD 就緒 -?`{0, 0}`：立即返回 -?`{tv_sec, tv_usec}`：指定超時時間（秒 + 微秒）
返回值	就緒 FD 數量；0 表示超時；-1 表示錯誤（如被信號中斷，`errno`?查看具體原因）。

（4）觸發模式：水平觸發（LT, Level Triggered）

核心邏輯：只要 FD 的事件條件滿足（如數據可讀），就會持續觸發事件，直到數據被處理。
示例場景：客戶端發送 10KB 數據，select?會多次觸發?EPOLLIN?事件，直到數據被完全讀取。

2. 使用步驟（監聽多個客戶端：從初始化到事件處理）

步驟 1：初始化事件集合

fd_set read_fds;  
FD_ZERO(&read_fds);  // 清空集合（必須第一步，避免臟數據）  
FD_SET(server_fd, &read_fds);  // 添加服務器監聽 FD（如 socket 描述符）

關鍵點：服務器啟動時，先將監聽套接字（server_fd）加入?readfds，用于檢測新客戶端連接。

步驟 2：計算?`maxfd`

int maxfd = server_fd;  // 初始時只有服務器 FD  
// 若有客戶端 FD（如 client_fd=5），則更新為 maxfd = client_fd

為什么 + 1？：select?函數需要檢測從 0 到?maxfd?的所有 FD，因此傳入參數為?maxfd + 1。

步驟 3：等待事件就緒（阻塞或超時）

struct timeval timeout = {2, 0};  // 2 秒超時（2 秒內無事件則返回）  
int ready_count = select(maxfd + 1, &read_fds, NULL, NULL, &timeout);

三種狀態：
- ready_count > 0：有?ready_count?個 FD 就緒。
- ready_count == 0：超時，無事件發生（可用于定時輪詢任務）。
- ready_count == -1：錯誤（如?EINTR?表示被信號中斷，需重新調用）。

步驟 4：遍歷檢查就緒 FD（線性掃描）

for (int fd = 0; fd <= maxfd; fd++) {  if (FD_ISSET(fd, &read_fds)) {  // 檢查 FD 是否在就緒集合中  if (fd == server_fd) {  // 處理新客戶端連接（accept）  int client_fd = accept(server_fd, ...);  FD_SET(client_fd, &read_fds);  // 將新客戶端 FD 添加到下次監聽集合  maxfd = (client_fd > maxfd) ? client_fd : maxfd;  // 更新 maxfd  } else {  // 處理客戶端數據（recv）  char buf[1024];  ssize_t recv_len = recv(fd, buf, sizeof(buf), 0);  if (recv_len == 0) {  // 客戶端關閉連接，移除 FD  FD_CLR(fd, &read_fds);  close(fd);  }  }  }  
}

核心缺陷：無論是否就緒，都需從?0?到?maxfd?逐個檢查（時間復雜度 O (n)），FD 越多性能越差。

3. 完整示例：select 實現簡易 TCP 服務器

#include <sys/select.h>  
#include <sys/socket.h>  
#include <arpa/inet.h>  
#include <unistd.h>  
#include <string.h>  #define PORT 8080  
#define MAX_FD 1024  // 受限于 FD_SETSIZE  int main() {  // 1. 創建服務器套接字  int server_fd = socket(AF_INET, SOCK_STREAM, 0);  struct sockaddr_in addr = {.sin_family = AF_INET, .sin_port = htons(PORT), .sin_addr.s_addr = INADDR_ANY};  bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));  listen(server_fd, 5);  fd_set read_fds;  int maxfd = server_fd;  while (1) {  FD_ZERO(&read_fds);  FD_SET(server_fd, &read_fds);  // 2. 添加所有客戶端 FD 到集合（假設客戶端 FD 存儲在數組 clients[] 中）  for (int i = 0; i < MAX_FD; i++) {  int client_fd = clients[i];  if (client_fd > 0) FD_SET(client_fd, &read_fds);  }  // 3. 等待事件（永久阻塞）  int ready = select(maxfd + 1, &read_fds, NULL, NULL, NULL);  if (ready < 0) { perror("select"); continue; }  // 4. 處理就緒 FD  for (int fd = 0; fd <= maxfd; fd++) {  if (FD_ISSET(fd, &read_fds)) {  if (fd == server_fd) {  // 處理新連接  int client_fd = accept(server_fd, NULL, NULL);  clients[client_idx++] = client_fd;  // 假設 clients 是全局數組  maxfd = (client_fd > maxfd) ? client_fd : maxfd;  } else {  // 處理數據接收  char buf[1024];  if (recv(fd, buf, sizeof(buf), 0) <= 0) {  close(fd);  FD_CLR(fd, &read_fds);  // 從集合中移除失效 FD  } else {  send(fd, buf, strlen(buf), 0);  // 簡單回顯  }  }  }  }  }  close(server_fd);  return 0;  
}

4. 優缺點對比與適用場景

（1）優點：入門友好，跨平臺

跨平臺支持：Windows（select）和 Linux 均支持，適合需要跨平臺的輕量級程序（如簡單代理工具）。
接口簡單：僅需操作?fd_set?集合，適合新手快速入門多路復用概念。
小規模場景適用：當 FD 數量較少（如 < 100）時，開發成本低，無需復雜配置。

（2）缺點：性能瓶頸明顯

FD 數量限制：受?FD_SETSIZE?限制（默認 1024），無法處理大規模并發（如萬級連接）。
內核拷貝開銷：每次調用?select?都需將整個?fd_set?從用戶空間拷貝到內核空間，FD 越多開銷越大。
線性掃描效率低：通過?FD_ISSET?逐個檢查 FD，時間復雜度為 O (n)，高并發時 CPU 占用率飆升。
集合重置麻煩：內核會修改?fd_set?集合（移除未就緒的 FD），每次調用前需重新調用?FD_ZERO/FD_SET?重置。

（3）適用場景

小規模并發：如聊天工具（客戶端數量 < 100）、簡單日志服務器。
跨平臺開發：需要同時支持 Windows 和 Linux 時，select?是唯一選擇。
學習階段：作為理解 IO 多路復用的入門接口，幫助掌握事件驅動基本思想。

5. 錯誤處理與最佳實踐

（1）常見錯誤碼處理

EINTR：select?被信號中斷（如?SIGINT），可忽略并重新調用。
EBADF：集合中包含無效 FD（如已關閉的 FD），需在?FD_ISSET?前檢查 FD 有效性。

（2）優化技巧

預分配 FD 數組：用數組存儲所有監聽的 FD，避免遍歷時檢查無效 FD（如 FD=0 可能是標準輸入）。
限制超時時間：避免永久阻塞（timeout=NULL），可設置短超時（如 1 秒），期間穿插其他任務（如定時心跳）。

（3）新手常見問題

Q：為什么每次調用 select 前要重置 fd_set？
A：內核會修改?fd_set?集合，移除未就緒的 FD，因此下次調用前需重新添加所有監聽的 FD。
Q：如何監聽可寫事件？
A：將目標 FD 添加到?writefds?集合，檢測是否可無阻塞寫入（如發送緩沖區未滿）。

6. 總結：select 的 “利” 與 “弊”

select 作為經典多路復用接口，是理解 IO 并發的重要起點，但其設計缺陷使其在高并發場景中逐漸被淘汰。對于新手，掌握 select 的核心在于理解位掩碼集合的操作和水平觸發機制，為后續學習 poll 和 epoll 打下基礎。在下一節中，我們將對比 poll 接口，了解其如何改進 select 的 FD 數量限制問題。

三、poll：改進的多路復用接口（適用于中規模并發）

1. 核心原理與數據結構

1.1 核心原理

poll?是 Linux 系統中用于實現 I/O 多路復用的系統調用，它改進了?select?存在的一些問題。poll?的核心原理是通過一個?struct pollfd?數組來管理多個文件描述符（FD），并允許內核監聽這些文件描述符上的特定事件。當其中任何一個文件描述符上的指定事件發生時，poll?函數會返回，通知程序哪些文件描述符已經就緒。

1.2 數據結構：`struct pollfd`

poll?使用?struct pollfd?數組來動態管理文件描述符，這個數組沒有固定的大小限制，僅受系統資源的約束。以下是?struct pollfd?的定義：

struct pollfd {int fd;            // 文件描述符（-1 表示忽略）short events;      // 監聽事件（如 POLLIN 可讀）short revents;     // 就緒事件（內核填充）
};

fd：要監聽的文件描述符。如果設置為 -1，則表示忽略該條目，poll?函數不會對其進行檢查。
events：指定要監聽的事件類型。可以使用按位或（|）運算符組合多個事件。常見的事件類型如下：
- POLLIN：文件描述符有普通數據可讀。例如，對于一個套接字，當有新的數據到達接收緩沖區時，就會觸發?POLLIN?事件。
- POLLOUT：文件描述符可寫，即發送緩沖區有空間可以寫入數據。比如在網絡編程中，當套接字的發送緩沖區有空閑空間時，就會觸發?POLLOUT?事件。
- POLLERR：文件描述符發生錯誤。這可能是由于網絡連接中斷、文件損壞等原因導致的。
- POLLHUP：文件描述符被掛起。例如，在 TCP 連接中，當對方關閉連接時，就會觸發?POLLHUP?事件。
- POLLNVAL：文件描述符無效。可能是因為文件描述符沒有被正確打開或者已經被關閉。
- POLLPRI：文件描述符有緊急數據可讀。在網絡編程中，緊急數據通常用于帶外數據傳輸，例如 TCP 的緊急指針機制。當有緊急數據到達時，會觸發?POLLPRI?事件。
revents：由內核填充的實際發生的事件。程序在?poll?函數返回后，可以檢查這個字段來確定哪些事件已經發生。

1.3 核心函數：`poll`

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

參數解釋：
- fds：指向?struct pollfd?數組的指針，該數組包含了要監聽的文件描述符及其相關事件。
- nfds：數組中有效元素的數量，即要監聽的文件描述符的數量。與?select?不同，poll?不需要計算最大的文件描述符加 1。
- timeout：超時時間，以毫秒為單位。其取值有以下幾種情況：
  - -1：表示永久阻塞，直到有文件描述符上的事件發生。
  - 0：表示立即返回，無論是否有事件發生。
  - 大于 0 的值：表示等待指定的毫秒數，如果在這段時間內沒有事件發生，則?poll?函數返回 0。
返回值：
- 大于 0：表示有?n?個文件描述符上的事件發生。
- 0：表示超時，在指定的時間內沒有文件描述符上的事件發生。
- -1：表示發生錯誤，錯誤信息存儲在?errno?中。

2. 使用步驟（監聽多個客戶端）

2.1 初始化?`pollfd`?數組

#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>#define MAX_FDS 1024int main() {// 創建服務器套接字int server_fd = socket(AF_INET, SOCK_STREAM, 0);if (server_fd == -1) {perror("socket");return 1;}// 綁定地址和端口struct sockaddr_in server_addr = {0};server_addr.sin_family = AF_INET;server_addr.sin_addr.s_addr = INADDR_ANY;server_addr.sin_port = htons(8080);if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {perror("bind");close(server_fd);return 1;}// 監聽連接if (listen(server_fd, 5) == -1) {perror("listen");close(server_fd);return 1;}// 初始化 pollfd 數組struct pollfd fds[MAX_FDS];fds[0].fd = server_fd;fds[0].events = POLLIN;int nfds = 1;// 后續代碼...
}

解釋：
- 首先創建了一個服務器套接字，并將其綁定到指定的地址和端口，然后開始監聽連接。
- 接著定義了一個?struct pollfd?數組?fds，大小為?MAX_FDS。
- 將服務器套接字的文件描述符賦值給?fds[0].fd，并設置要監聽的事件為?POLLIN（即有新的連接請求可讀）。
- nfds?表示當前?fds?數組中有效元素的數量，初始值為 1，因為只有服務器套接字被添加到了數組中。

2.2 等待事件就緒

    // ... 前面的代碼 ...while (1) {int ready = poll(fds, nfds, 2000);  // 2000 毫秒超時if (ready == -1) {perror("poll");break;} else if (ready == 0) {printf("Timeout, no events occurred.\n");continue;}// 后續代碼...}// ... 后面的代碼 ...

解釋：
- 使用?poll?函數等待事件發生，設置超時時間為 2000 毫秒。
- 如果?poll?函數返回 -1，表示發生錯誤，使用?perror?輸出錯誤信息并跳出循環。
- 如果返回 0，表示超時，在 2000 毫秒內沒有文件描述符上的事件發生，打印提示信息并繼續下一次循環。
- 如果返回值大于 0，表示有文件描述符上的事件發生，繼續后續的處理。

2.3 遍歷檢查就緒事件

    // ... 前面的代碼 ...for (int i = 0; i < nfds; i++) {if (fds[i].fd == -1 || !(fds[i].revents & POLLIN)) continue;if (fds[i].fd == server_fd) {// 處理新的連接請求struct sockaddr_in client_addr = {0};socklen_t client_addr_len = sizeof(client_addr);int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);if (client_fd == -1) {perror("accept");continue;}// 將新的客戶端套接字添加到 pollfd 數組中if (nfds < MAX_FDS) {fds[nfds].fd = client_fd;fds[nfds].events = POLLIN | POLLPRI;nfds++;} else {printf("Too many clients, rejecting new connection.\n");close(client_fd);}} else {// 處理客戶端數據char buffer[1024];ssize_t bytes_read;if (fds[i].revents & POLLPRI) {// 處理緊急數據bytes_read = recv(fds[i].fd, buffer, sizeof(buffer), MSG_OOB);if (bytes_read == -1) {perror("recv urgent data");} else {buffer[bytes_read] = '\0';printf("Received urgent data from client: %s\n", buffer);}}if (fds[i].revents & POLLIN) {bytes_read = recv(fds[i].fd, buffer, sizeof(buffer), 0);if (bytes_read == -1) {perror("recv");close(fds[i].fd);fds[i].fd = -1;  // 標記為忽略} else if (bytes_read == 0) {// 客戶端關閉連接close(fds[i].fd);fds[i].fd = -1;  // 標記為忽略} else {// 處理接收到的數據buffer[bytes_read] = '\0';printf("Received from client: %s\n", buffer);// 回顯數據給客戶端send(fds[i].fd, buffer, bytes_read, 0);}}}}// ... 后面的代碼 ...

解釋：
- 遍歷?fds?數組，對于每個元素，首先檢查?fds[i].fd?是否為 -1，如果是，則表示該條目被忽略，跳過本次循環。
- 然后檢查?fds[i].revents?是否包含?POLLIN?事件，如果不包含，則表示該文件描述符上沒有可讀事件發生，跳過本次循環。
- 如果?fds[i].fd?等于服務器套接字的文件描述符，表示有新的連接請求，使用?accept?函數接受連接，并將新的客戶端套接字添加到?fds?數組中，同時更新?nfds?的值。這里監聽客戶端套接字的?POLLIN?和?POLLPRI?事件。
- 如果?fds[i].fd?不等于服務器套接字的文件描述符，表示有客戶端數據可讀或有緊急數據到達。
  - 當?fds[i].revents?包含?POLLPRI?事件時，使用?recv?函數并設置?MSG_OOB?標志來接收緊急數據。
  - 當?fds[i].revents?包含?POLLIN?事件時，使用?recv?函數接收普通數據。
    - 如果?recv?函數返回 -1，表示發生錯誤，關閉該客戶端套接字，并將?fds[i].fd?設置為 -1 以標記為忽略。
    - 如果?recv?函數返回 0，表示客戶端關閉了連接，同樣關閉該客戶端套接字，并將?fds[i].fd?設置為 -1。
    - 如果?recv?函數返回值大于 0，表示成功接收到數據，將數據打印出來，并使用?send?函數將數據回顯給客戶端。

3. 優缺點

3.1 優點

無 FD 數量硬編碼限制：與?select?不同，poll?沒有?FD_SETSIZE?這樣的硬編碼限制，僅受系統資源的約束。這意味著可以處理更多的文件描述符，適用于中規模并發的場景。
事件類型更清晰：poll?使用?POLLIN、POLLOUT、POLLERR、POLLHUP、POLLNVAL、POLLPRI?等明確的事件類型，比?select?使用的?fd_set?位掩碼更易于理解和使用。開發者可以更方便地指定要監聽的事件類型，并且在處理事件時也更加直觀。

3.2 缺點

仍需線性掃描就緒 FD：poll?函數返回后，程序需要遍歷?struct pollfd?數組來檢查哪些文件描述符上的事件已經發生。這個過程的時間復雜度為 O (n)，其中 n 是要監聽的文件描述符的數量。當文件描述符數量較多時，線性掃描會消耗較多的 CPU 時間，影響性能。
每次調用需復制?pollfd?數組到內核：與?select?類似，poll?函數在每次調用時都需要將?struct pollfd?數組從用戶空間復制到內核空間。雖然?poll?在性能上優于?select，但這種復制操作仍然會帶來一定的開銷，尤其是在處理大量文件描述符時。

4. 拓展：錯誤處理和性能優化建議

4.1 錯誤處理

在使用?poll?函數時，需要對可能出現的錯誤進行處理。常見的錯誤情況包括：

EBADF：fds?數組中包含無效的文件描述符。在使用?poll?之前，應該確保所有的文件描述符都是有效的。
EFAULT：fds?數組的指針無效，可能是因為指針指向了無效的內存地址。
EINTR：poll?函數被信號中斷。在這種情況下，可以重新調用?poll?函數繼續等待事件。

以下是一個簡單的錯誤處理示例：

    int ready = poll(fds, nfds, 2000);if (ready == -1) {switch (errno) {case EBADF:printf("Invalid file descriptor in fds array.\n");break;case EFAULT:printf("Invalid pointer to fds array.\n");break;case EINTR:printf("Poll was interrupted by a signal, retrying...\n");continue;default:perror("poll");break;}}

4.2 性能優化建議

合理設置超時時間：根據具體的應用場景，合理設置?poll?函數的超時時間。如果設置的超時時間過長，可能會導致程序在沒有事件發生時長時間阻塞；如果設置的超時時間過短，可能會導致?poll?函數頻繁返回，增加系統開銷。
動態管理?pollfd?數組：在實際應用中，可能會有新的文件描述符需要添加到?poll?監聽列表中，或者有一些文件描述符不再需要監聽。可以動態地管理?struct pollfd?數組，避免不必要的文件描述符被監聽，從而減少線性掃描的時間。
結合多線程或多進程：對于高并發的場景，可以結合多線程或多進程來處理?poll?函數返回的就緒事件。每個線程或進程可以負責處理一部分文件描述符，從而提高程序的并發處理能力。

通過以上的學習，你應該對?poll?函數有了更深入的理解，并且能夠使用它來實現一個簡單的多客戶端服務器。在實際應用中，可以根據具體的需求和場景，選擇合適的 I/O 多路復用機制。

四、epoll：Linux 高并發終極方案（適用于萬級以上連接）

1. 核心原理與數據結構

1.1 核心原理

epoll?是 Linux 內核為處理大批量文件描述符而作了改進的?I/O?多路復用技術。其核心原理是使用一個事件表來記錄所有關注的文件描述符及其事件，當有事件發生時，內核會將這些就緒的事件通知給用戶空間。epoll?通過紅黑樹和鏈表這兩種數據結構來高效地管理文件描述符和就緒事件，避免了像?select?和?poll?那樣的線性掃描和大量的數據拷貝，從而在高并發場景下表現出卓越的性能。

1.2 數據結構

紅黑樹

紅黑樹是一種自平衡的二叉搜索樹，epoll?使用紅黑樹來管理所有監聽的文件描述符（FD）。紅黑樹的特點是插入、刪除和查找操作的時間復雜度都是?O(logN)，其中?N?是樹中節點的數量。在?epoll?中，紅黑樹的每個節點代表一個被監聽的文件描述符，通過紅黑樹可以快速地添加、刪除和修改監聽的文件描述符。

鏈表

鏈表用于存儲就緒事件。當有文件描述符上的事件就緒時，內核會將這些事件添加到鏈表中。epoll_wait?函數直接從這個鏈表中獲取就緒事件，而不需要像?select?和?poll?那樣掃描所有的文件描述符，從而大大提高了效率。

1.3 核心函數

#include <sys/epoll.h>
int epoll_create(int size);           // 創建 epoll 實例（size 為預估 FD 數）
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

epoll_create?函數
- 功能：創建一個?epoll?實例，并返回一個文件描述符（epfd），用于后續的?epoll?操作。
- 參數：
  - size：該參數在 Linux 2.6.8 之后被忽略，但必須為正數。它最初用于告訴內核需要監聽的文件描述符的大致數量。
- 返回值：成功時返回一個非負的文件描述符，失敗時返回 -1，并設置?errno。
epoll_ctl?函數
- 功能：用于控制?epoll?實例中的文件描述符，包括添加、修改和刪除監聽的文件描述符及其事件。
- 參數：
  - epfd：epoll?實例的文件描述符，由?epoll_create?函數返回。
  - op：操作類型，有以下三種取值：
    - EPOLL_CTL_ADD：將指定的文件描述符添加到?epoll?實例中，并監聽指定的事件。
    - EPOLL_CTL_MOD：修改已經添加到?epoll?實例中的文件描述符的監聽事件。
    - EPOLL_CTL_DEL：從?epoll?實例中刪除指定的文件描述符。
  - fd：要操作的文件描述符。
  - event：指向?struct epoll_event?結構體的指針，用于指定要監聽的事件類型和關聯的數據。
- 返回值：成功時返回 0，失敗時返回 -1，并設置?errno。
epoll_wait?函數
- 功能：等待?epoll?實例中監聽的文件描述符上的事件發生。當有事件發生時，將就緒的事件信息復制到?events?數組中。
- 參數：
  - epfd：epoll?實例的文件描述符。
  - events：指向?struct epoll_event?數組的指針，用于存儲就緒的事件信息。
  - maxevents：events?數組的最大元素個數，即最多可以返回的就緒事件數量。
  - timeout：超時時間，以毫秒為單位。取值如下：
    - -1：表示永久阻塞，直到有事件發生。
    - 0：表示立即返回，無論是否有事件發生。
    - 大于 0 的值：表示等待指定的毫秒數，如果在這段時間內沒有事件發生，則返回 0。
- 返回值：返回就緒的事件數量，即?events?數組中有效的元素個數。如果發生錯誤，返回 -1，并設置?errno。

1.4?`struct epoll_event`?結構體

struct epoll_event {uint32_t events;       // 事件類型（如 EPOLLIN/EPOLLET）epoll_data_t data;     // 存儲 FD 或自定義數據
};

events：表示要監聽的事件類型或已經發生的事件類型。常見的事件類型有：
- EPOLLIN：文件描述符有數據可讀。
- EPOLLOUT：文件描述符可寫。
- EPOLLERR：文件描述符發生錯誤。
- EPOLLHUP：文件描述符被掛起。
- EPOLLET：設置為邊緣觸發模式（默認是水平觸發模式）。
data：epoll_data_t?是一個聯合體，用于存儲與文件描述符關聯的數據。常見的用法是存儲文件描述符本身，也可以存儲自定義的指針或整數值。

typedef union epoll_data {void        *ptr;int          fd;uint32_t     u32;uint64_t     u64;
} epoll_data_t;

2. 觸發模式（關鍵特性）

2.1 水平觸發（LT，默認模式）

特點

水平觸發（Level Triggered，LT）是?epoll?的默認觸發模式。在這種模式下，只要文件描述符上的事件條件滿足（例如，有數據可讀），就會持續觸發相應的事件。也就是說，如果一次沒有將數據完全讀取完，epoll?會再次觸發?EPOLLIN?事件，直到數據被完全讀取。這種模式適合處理低速?I/O?操作，因為它允許程序有足夠的時間來處理數據。

代碼示例

#include <stdio.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <string.h>#define BUFFER_SIZE 1024int main() {struct epoll_event event;int fd = STDIN_FILENO;  // 標準輸入文件描述符// 創建 epoll 實例int epfd = epoll_create(1);if (epfd == -1) {perror("epoll_create");return 1;}// 設置監聽事件為水平觸發，數據可讀時觸發event.events = EPOLLIN;event.data.fd = fd;// 將文件描述符添加到 epoll 實例中if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event) == -1) {perror("epoll_ctl");close(epfd);return 1;}struct epoll_event events[1];char buf[BUFFER_SIZE];while (1) {// 等待事件發生int ready = epoll_wait(epfd, events, 1, -1);if (ready == -1) {perror("epoll_wait");break;}if (events[0].events & EPOLLIN) {// 處理數據while (recv(fd, buf, sizeof(buf), 0) > 0) {// 這里可以添加具體的數據處理邏輯printf("Received data: %s\n", buf);memset(buf, 0, sizeof(buf));}}}close(epfd);return 0;
}

2.2 邊緣觸發（ET，高性能模式）

特點

邊緣觸發（Edge Triggered，ET）是一種高性能的觸發模式。在這種模式下，只有當文件描述符上的事件狀態發生變化（例如，有新的數據到達）時，才會觸發一次事件。也就是說，一旦事件被觸發，程序必須一次性將所有的數據讀取完，否則后續即使還有數據，也不會再次觸發事件。因此，在邊緣觸發模式下，文件描述符必須設置為非阻塞模式，以確保能夠一次性讀取完所有數據。

使用條件

使用邊緣觸發模式時，文件描述符必須設置為非阻塞模式。可以使用?fcntl?函數來設置文件描述符的屬性。

#include <fcntl.h>// 設置文件描述符為非阻塞模式
int flags = fcntl(fd, F_GETFL, 0);
if (flags == -1) {perror("fcntl");return 1;
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {perror("fcntl");return 1;
}

代碼示例

#include <stdio.h>
#include <sys/epoll.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>#define BUFFER_SIZE 1024int main() {struct epoll_event event;int fd = STDIN_FILENO;  // 標準輸入文件描述符// 設置文件描述符為非阻塞模式int flags = fcntl(fd, F_GETFL, 0);if (flags == -1) {perror("fcntl");return 1;}if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {perror("fcntl");return 1;}// 創建 epoll 實例int epfd = epoll_create(1);if (epfd == -1) {perror("epoll_create");return 1;}// 設置監聽事件為邊緣觸發，數據可讀時觸發event.events = EPOLLIN | EPOLLET;event.data.fd = fd;// 將文件描述符添加到 epoll 實例中if (epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event) == -1) {perror("epoll_ctl");close(epfd);return 1;}struct epoll_event events[1];char buf[BUFFER_SIZE];while (1) {// 等待事件發生int ready = epoll_wait(epfd, events, 1, -1);if (ready == -1) {perror("epoll_wait");break;}if (events[0].events & EPOLLIN) {// 處理數據while (1) {ssize_t len = recv(fd, buf, sizeof(buf), 0);if (len == -1 && errno != EAGAIN) {perror("recv");break;} else if (len == -1 && errno == EAGAIN) {// 無數據時退出break;} else if (len == 0) {// 對方關閉連接break;} else {// 處理接收到的數據printf("Received data: %s\n", buf);memset(buf, 0, sizeof(buf));}}}}close(epfd);return 0;
}

3. 使用步驟（高并發服務器）

3.1 創建 epoll 實例

#include <sys/epoll.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>#define MAX_EVENTS 1024int main() {// 創建服務器套接字int server_fd = socket(AF_INET, SOCK_STREAM, 0);if (server_fd == -1) {perror("socket");return 1;}// 綁定地址和端口struct sockaddr_in server_addr = {0};server_addr.sin_family = AF_INET;server_addr.sin_addr.s_addr = INADDR_ANY;server_addr.sin_port = htons(8080);if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {perror("bind");close(server_fd);return 1;}// 監聽連接if (listen(server_fd, 5) == -1) {perror("listen");close(server_fd);return 1;}// 創建 epoll 實例int epfd = epoll_create(1024);if (epfd == -1) {perror("epoll_create");close(server_fd);return 1;}// 后續代碼...
}

解釋：首先創建一個服務器套接字，并將其綁定到指定的地址和端口，然后開始監聽連接。接著使用?epoll_create?函數創建一個?epoll?實例，返回的文件描述符?epfd?用于后續的?epoll?操作。

3.2 添加監聽事件

    struct epoll_event event;event.events = EPOLLIN;event.data.fd = server_fd;// 將服務器套接字添加到 epoll 實例中if (epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &event) == -1) {perror("epoll_ctl");close(epfd);close(server_fd);return 1;}// 后續代碼...

解釋：創建一個?struct epoll_event?結構體變量?event，設置要監聽的事件為?EPOLLIN（即有新的連接請求可讀），并將服務器套接字的文件描述符存儲在?event.data.fd?中。然后使用?epoll_ctl?函數將服務器套接字添加到?epoll?實例中進行監聽。

3.3 等待就緒事件

    struct epoll_event events[MAX_EVENTS];while (1) {// 等待事件發生，永久阻塞int ready = epoll_wait(epfd, events, MAX_EVENTS, -1);if (ready == -1) {perror("epoll_wait");break;}// 后續代碼...}close(epfd);close(server_fd);return 0;
}

解釋：定義一個?struct epoll_event?數組?events，用于存儲就緒的事件信息。使用?epoll_wait?函數等待事件發生，設置超時時間為 -1，表示永久阻塞，直到有事件發生。當有事件發生時，epoll_wait?函數返回就緒的事件數量。

3.4 處理就緒事件

        for (int i = 0; i < ready; i++) {int fd = events[i].data.fd;if (fd == server_fd) {// 處理新連接struct sockaddr_in client_addr = {0};socklen_t client_addr_len = sizeof(client_addr);int client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &client_addr_len);if (client_fd == -1) {perror("accept");continue;}// 設置客戶端套接字為非阻塞模式int flags = fcntl(client_fd, F_GETFL, 0);if (flags == -1) {perror("fcntl");close(client_fd);continue;}if (fcntl(client_fd, F_SETFL, flags | O_NONBLOCK) == -1) {perror("fcntl");close(client_fd);continue;}// 將客戶端套接字添加到 epoll 實例中struct epoll_event client_event;client_event.events = EPOLLIN | EPOLLET;  // 邊緣觸發模式client_event.data.fd = client_fd;if (epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &client_event) == -1) {perror("epoll_ctl");close(client_fd);}} else {// 處理客戶端數據char buffer[1024];while (1) {ssize_t len = recv(fd, buffer, sizeof(buffer), 0);if (len == -1 && errno != EAGAIN) {perror("recv");close(fd);epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);break;} else if (len == -1 && errno == EAGAIN) {// 無數據時退出break;} else if (len == 0) {// 客戶端關閉連接close(fd);epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);break;} else {// 處理接收到的數據buffer[len] = '\0';printf("Received from client: %s\n", buffer);// 回顯數據給客戶端send(fd, buffer, len, 0);}}}}

解釋：遍歷?events?數組，對于每個就緒的事件，首先獲取其關聯的文件描述符?fd。如果?fd?等于服務器套接字的文件描述符，表示有新的連接請求，使用?accept?函數接受連接，并將新的客戶端套接字設置為非阻塞模式，然后將其添加到?epoll?實例中進行監聽。如果?fd?不等于服務器套接字的文件描述符，表示有客戶端數據可讀，使用?recv?函數接收數據，并根據接收結果進行相應的處理。

4. 優缺點

4.1 優點

高性能：epoll?使用紅黑樹和鏈表來管理文件描述符和就緒事件，就緒事件通過鏈表直接返回，時間復雜度接近?O(1)。相比?select?和?poll?的線性掃描，epoll?在處理大量文件描述符時具有明顯的性能優勢。
無 FD 限制：epoll?僅受系統最大打開文件數的限制，默認情況下，系統最大打開文件數為 1024，但可以通過?ulimit -n?命令進行調整。因此，epoll?可以處理萬級以上的連接。
靈活觸發模式：epoll?支持水平觸發（LT）和邊緣觸發（ET）兩種模式，開發者可以根據不同的應用場景選擇合適的觸發模式。邊緣觸發模式適合處理高速網絡?I/O，可以減少事件觸發的次數，提高效率。

4.2 缺點

僅 Linux 支持：epoll?是 Linux 特有的接口，在 Windows 等其他操作系統上沒有對應的實現。如果需要開發跨平臺的網絡應用程序，需要使用其他的?I/O?多路復用技術。
ET 模式需手動處理非阻塞 IO：邊緣觸發模式要求文件描述符必須設置為非阻塞模式，并且需要手動處理非阻塞?I/O?操作，這增加了代碼的復雜度。如果處理不當，可能會導致數據丟失或程序出現異常。

5. 拓展：錯誤處理和性能優化

5.1 錯誤處理

在使用?epoll?函數時，需要對可能出現的錯誤進行處理。常見的錯誤情況包括：

EFAULT：events?數組指針無效，可能是因為指針指向了無效的內存地址。
EINTR：epoll_wait?函數被信號中斷。在這種情況下，可以重新調用?epoll_wait?函數繼續等待事件。
EBADF：epfd?不是一個有效的?epoll?實例文件描述符。
EINVAL：epfd?不是一個?epoll?實例文件描述符，或者?maxevents?小于等于 0。

以下是一個簡單的錯誤處理示例：

    int ready = epoll_wait(epfd, events, MAX_EVENTS, -1);if (ready == -1) {switch (errno) {case EFAULT:printf("Invalid events array pointer.\n");break;case EINTR:printf("epoll_wait was interrupted by a signal, retrying...\n");continue;case EBADF:printf("Invalid epoll instance file descriptor.\n");break;case EINVAL:printf("Invalid epoll instance or maxevents value.\n");break;default:perror("epoll_wait");break;}}

5.2 性能優化

合理設置?maxevents：maxevents?參數表示?events?數組的最大元素個數，即最多可以返回的就緒事件數量。應該根據實際情況合理設置這個參數，避免設置過大或過小。如果設置過小，可能需要多次調用?epoll_wait?函數才能處理完所有的就緒事件；如果設置過大，會浪費內存空間。
批量處理事件：在處理就緒事件時，可以采用批量處理的方式，減少系統調用的次數。例如，可以將多個客戶端的請求合并處理，提高處理效率。
使用線程池：對于高并發的場景，可以使用線程池來處理就緒事件。每個線程負責處理一部分客戶端的請求，避免單個線程處理過多的請求導致性能下降。

通過以上的學習，你應該對?epoll?有了更深入的理解，并且能夠使用它來實現一個高并發的服務器。在實際應用中，可以根據具體的需求和場景，充分發揮?epoll?的優勢，提高網絡應用程序的性能。

五、三者核心對比表

特性	select	poll	epoll
數據結構	`fd_set`（位掩碼，固定大小）	`pollfd`?數組（動態）	紅黑樹（管理 FD）+ 鏈表（就緒事件）
FD 限制	FD_SETSIZE（默認 1024）	受限于系統?`ulimit -n`	理論無限制（僅受內存影響）
內核操作	每次復制 FD 集合到內核	每次復制 pollfd 數組到內核	僅首次添加 FD 到內核（增量更新）
就緒通知	水平觸發（LT），線性掃描所有 FD	水平觸發（LT），掃描就緒 FD	支持 LT/ET，直接返回就緒列表
時間復雜度	O(n)	O(n)	O (1)（僅處理就緒事件）
內存拷貝	高（每次 select 全量拷貝）	中（每次 poll 全量拷貝）	低（僅 epoll_ctl 時增量拷貝）
跨平臺	支持（Windows/Linux）	僅 Linux/UNIX 支持	僅 Linux 支持
典型場景	小規模并發（FD < 1024）	中規模并發（FD 中等數量）	高并發（FD 萬級以上）