本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視
> https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章將同步到我的個人部落格：
> www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《不可輕視的Java網路程式設計》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。

該系列博文會告訴你如何從計算機網路的基礎知識入手，一步步地學習Java網路基礎，從socket到nio、bio、aio和netty等網路程式設計知識，並且進行實戰，網路程式設計是每一個Java後端工程師必須要學習和理解的知識點，進一步來說，你還需要掌握Linux中的網路程式設計原理，包括IO模型、網路程式設計框架netty的進階原理，才能更完整地瞭解整個Java網路程式設計的知識體系，形成自己的知識框架。

為了更好地總結和檢驗你的學習成果，本系列文章也會提供部分知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

## 為什麼要 I/O 多路複用

當需要從一個叫 `r_fd` 的描述符不停地讀取資料，並把讀到的資料寫入一個叫 `w_fd` 的描述符時，我們可以用迴圈使用阻塞 I/O ：

while((n = read(r_fd, buf, BUF_SIZE)) > 0)
        if(write(w_fd, buf, n) != n)
            err_sys("write error");

但是，如果要從兩個地方讀取資料呢？這時，不能再使用會把程式阻塞住的 `read` 函式。因為可能在阻塞地等待 `r_fd1` 的資料時，來不及處理 `r_fd2`，已經到達的 `r_fd2` 的資料可能會丟失掉。

這個情況下需要使用**非阻塞 I/O**。

只要做個標記，把檔案描述符標記為非阻塞的，以後再對它使用 `read` 函式：如果它還沒有資料可讀，函式會立即返回並把 errorno 這個變數的值設定為 35，於是我們知道它沒有資料可讀，然後可以立馬去對其他描述符使用 `read`；如果它有資料可讀，我們就讀取它資料。對所有要讀的描述符都呼叫了一遍 `read` 之後，我們可以等一個較長的時間（比如幾秒），然後再從第一個檔案描述符開始呼叫 `read` 。這種迴圈就叫做**輪詢**（polling）。

這樣，不會像使用阻塞 I/O 時那樣因為一個描述符 `read` 長時間處於等待資料而使程式阻塞。

輪詢的缺點是浪費太多 CPU 時間。大多數時候我們沒有資料可讀，但是還是用了 `read` 這個**系統呼叫**，使用系統呼叫時會從使用者態切換到核心態。而大多數情況下我們呼叫 `read`，然後陷入核心態，核心發現這個描述符沒有準備好，然後切換回使用者態並且只得到 EAGAIN （errorno 被設定為 35），做的是無用功。描述符非常多的時候，每次的切換過程就是巨大的浪費。

所以，需要 **I/O 多路複用**。I/O 多路複用透過使用一個系統函式，同時等待多個描述符的可讀、可寫狀態。

為了達到這個目的，我們需要做的是：建立一個描述符列表，以及我們分別關心它們的什麼事件（可讀還是可寫還是發生例外情況）；呼叫一個系統函式，直到這個描述符列表裡有至少一個描述符關聯的事件發生時，這個函式才會返回。

select, poll, epoll 就是這樣的系統函式。

### [](https://jeff.wtf/2017/02/IO-multiplexing/#select "select")select

我們可以在所有 POSIX 相容的系統裡使用 select 函式來進行 I/O 多路複用。我們需要透過 select 函式的引數傳遞給核心的資訊有：

*   我們關心哪些描述符
    *   我們關心它們的什麼事件
    *   我們希望等待多長時間

select 的返回時，核心會告訴我們：
    
    *   可讀的描述符的個數
    *   哪些描述符發生了哪些事件

#include <sys>
    int select(int maxfdp1, fd_set* readfds,
               fd_set* writefds, fd_set* exceptfds,
               struct timeval* timeout);
    
    // 返回值: 已就緒的描述符的個數。超時時為 0 ，錯誤時為 -1

`maxfdp1` 意思是 “max file descriptor plus 1” ，就是把你要監視的所有檔案描述符裡最大的那個加上 1 。（它實際上決定了核心要遍歷檔案描述符的次數，比如你監視了檔案描述符 5 和 20 並把 `maxfdp1` 設定為 21 ，核心每次都會從描述符 0 依次檢查到 20。）

中間的三個引數是你想監視的檔案描述符的集合。可以把 fd_set 型別視為 1024 位的二進位制數，這意味著 select 只能監視小於 1024 的檔案描述符（1024 是由 Linux 的 sys/select.h 裡 `FD_SETSIZE` 宏設定的值）。在 select 返回後我們透過 `FD_ISSET` 來判斷代表該位的描述符是否是已準備好的狀態。

最後一個引數是等待超時的時長：到達這個時長但是沒有任一描述符可用時，函式會返回 0 。

用一個程式碼片段來展示 select 的用法：

// 這個例子要監控檔案描述符 3, 4 的可讀狀態，以及 4, 5 的可寫狀態
        
        // 初始化兩個 fd_set 以及 timeval
        fd_set read_set, write_set;
        FD_ZERO(read_set);
        FD_ZERO(write_set);
        timeval t;
        t.tv_sec = 5;   // 超時為 5 秒
        t.tv_usec = 0;  // 加 0 微秒
        
        // 設定好兩個 fd_set
        int fd1 = 3;
        int fd2 = 4;
        int fd3 = 5;
        int maxfdp1 = 5 + 1;
        FD_SET(fd1, &read_set);
        FD_SET(fd2, &read_set);
        FD_SET(fd2, &write_set);
        FD_SET(fd3, &write_set);
        
        // 準備備用的 fd_set
        fd_set r_temp = read_set;
        fd_set w_temp = write_set;
        
        while(true){
            // 每次都要重新設定放入 select 的 fd_set
            read_set = r_temp;
            write_set = w_temp;
        
            // 使用 select
            int n = select(maxfdp1, &read_set, &write_set, NULL, &t);
        
            // 上面的 select 函式會一直阻塞，直到
            // 3, 4 可讀以及 4, 5 可寫這四件事中至少一項發生
            // 或者等待時間到達 5 秒，返回 0
        
            for(int i=0; i<maxfdp1 n="">0; i++){
                if(FD_ISSET(i, &read_set)){
                    n--;
                    if(i==fd1)
                        prinf("描述符 3 可讀");
                    if(i==fd2)
                        prinf("描述符 4 可讀");
                }
                if(FD_ISSET(i, &write_set)){
                    n--;
                    if(i==fd2)
                        prinf("描述符 3 可寫");
                    if(i==fd3)
                        prinf("描述符 4 可寫");
                }
            }
            // 上面的 printf 語句換成對應的 read 或者 write 函式就
            // 可以立即讀取或者寫入相應的描述符而不用等待
        }

可以看到，select 的缺點有：

*   預設能監視的檔案描述符不能大於 1024，也代表監視的總數不超過1024。即使你因為需要監視的描述符大於 1024 而改動核心的 `FD_SETSIZE` 值，但由於 select 是每次都會線性掃描整個fd_set，集合越大速度越慢，所以效能會比較差。
*   select 函式返回時只能看見已準備好的描述符數量，至於是哪個描述符準備好了需要迴圈用 `FD_ISSET` 來檢查，當未準備好的描述符很多而準備好的很少時，效率比較低。
*   select 函式每次執行的時候，都把引數裡傳入的三個 fd_set 從使用者空間複製到核心空間。而每次 fd_set 裡要監視的描述符變化不大時，全部重新複製一遍並不划算。同樣在每次都是未準備好的描述符很多而準備好的很少時，呼叫 select 會很頻繁，使用者/核心間的的資料複製就成了一個大的開銷。

還有一個問題是在程式碼的寫法上給我一些困擾的，就是每次呼叫 select 前必須重新設定三個 fd_set。 fd_set 型別只是 1024 位的二進位制數（實際上結構體裡是幾個 long 變數的陣列；比如 64 位機器上 long 是 64 bit，那麼 fd_set 裡就是 16 個 long 變數的陣列），由一位的 1 和 0 代表一個檔案描述符的狀態，但是其實呼叫 select 前後位的 1/0 狀態意義是不一樣的。

先講一下幾個對 fd_set 操作的函式的作用：`FD_ZERO` 把 fd_set 所有位設定為 0 ；`FD_SET` 把一個位設定為 1 ；`FD_ISSET` 判斷一個位是否為 1 。

呼叫 select 前：我們用 `FD_ZERO` 把 fd_set 先全部初始化，然後用 `FD_SET` 把我們關心的代表描述符的位設定為 1 。我們這時可以用 `FD_ISSET` 判斷這個位是否被我們設定，這時的含義是**我們想要監視的描述符是否被設定為被監視的狀態**。

呼叫 select 時：核心判斷 fd_set 裡的位並把各個 fd_set 裡所有值為 1 的位記錄下來，然後把 fd_set 全部設定成 0 ；一個描述符上有對應的事件發生時，把對應 fd_set 裡代表這個描述符的位設定為 1 。

在 select 返回之後：我們同樣用 `FD_ISSET` 判斷各個我們關心的位是 0 還是 1 ，這時的含義是，**這個位是否是發生了我們關心的事件**。

所以，在下一次呼叫 select 前，我們不得不把已經被核心改掉的 fd_set 全部重新設定一下。

select 在監視大量描述符尤其是更多的描述符未準備好的情況時效能很差。《Unix 高階程式設計》裡寫，用 select 的程式通常只使用 3 到 10 個描述符。

### [](https://jeff.wtf/2017/02/IO-multiplexing/#poll "poll")poll

poll 和 select 是相似的，只是給的介面不同。

#include <poll.h>
    int poll(struct pollfd fdarray[], nfds_t nfds, int timeout);
    
    // 返回值: 已就緒的描述符的個數。超時時為 0 ，錯誤時為 -1
`fdarray` 是 `pollfd` 的陣列。`pollfd` 結構體是這樣的：

struct pollfd {
        int fd;         // 檔案描述符
        short events;   // 我期待的事件
        short revents;  // 實際發生的事件：我期待的事件中發生的；或者異常情況
    };

`nfds` 是 `fdarray` 的長度，也就是 pollfd 的個數。

`timeout` 代表等待超時的毫秒數。

相比 select ，poll 有這些優點：由於 poll 在 pollfd 裡用 `int fd` 來表示檔案描述符而不像 select 裡用的 fd_set 來分別表示描述符，所以沒有必須小於 1024 的限制，也沒有數量限制；由於 poll 用 `events` 表示期待的事件，透過修改 `revents` 來表示發生的事件，所以不需要像 select 在每次呼叫前重新設定描述符和期待的事件。

除此之外，poll 和 select 幾乎相同。在 poll 返回後，需要遍歷 `fdarray` 來檢查各個 `pollfd` 裡的 `revents` 是否發生了期待的事件；每次呼叫 poll 時，把 `fdarray` 複製到核心空間。在描述符太多而每次準備好的較少時，poll 有同樣的效能問題。

### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll "epoll")epoll

epoll 是在 Linux 2.5.44 中首度登場的。不像 select 和 poll ，它提供了三個系統函式而不是一個。

#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-create-%E7%94%A8%E6%9D%A5%E5%88%9B%E5%BB%BA%E4%B8%80%E4%B8%AA-epoll-%E6%8F%8F%E8%BF%B0%E7%AC%A6%EF%BC%9A "epoll_create 用來建立一個 epoll 描述符：")epoll_create 用來建立一個 epoll 描述符：

#include <sys>
    int epoll_create(int size);
    
    // 返回值：epoll 描述符
`size` 用來告訴核心你想監視的檔案描述符的數目，但是它**並不是限制了能監視的描述符的最大個數**，而是給核心最初分配的空間一個建議。然後系統會在核心中分配一個空間來存放事件表，並返回一個 **epoll 描述符**，用來操作這個事件表。

#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-ctl-%E7%94%A8%E6%9D%A5%E5%A2%9E-%E5%88%A0-%E6%94%B9%E5%86%85%E6%A0%B8%E4%B8%AD%E7%9A%84%E4%BA%8B%E4%BB%B6%E8%A1%A8%EF%BC%9A "epoll_ctl 用來增/刪/改核心中的事件表：")epoll_ctl 用來增/刪/改核心中的事件表：

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    
    // 返回值：成功時返回 0 ，失敗時返回 -1

`epfd` 是 epoll 描述符。

`op` 是操作型別（增加/刪除/修改）。

`fd` 是希望監視的檔案描述符。

`event` 是一個 epoll_event 結構體的指標。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_data_t data;        // 使用者資料變數
    };

這個結構體裡，除了期待的事件外，還有一個 `data` ，是一個 union，它是用來讓我們在得到下面第三個函式的返回值以後方便的定位檔案描述符的。

#### [](https://jeff.wtf/2017/02/IO-multiplexing/#epoll-wait-%E7%94%A8%E6%9D%A5%E7%AD%89%E5%BE%85%E4%BA%8B%E4%BB%B6 "epoll_wait 用來等待事件")epoll_wait 用來等待事件

int epoll_wait(int epfd, struct epoll_event *result_events,
                  int maxevents, int timeout);
    
    // 返回值：已就緒的描述符個數。超時時為 0 ，錯誤時為 -1
`epfd` 是 epoll 描述符。

`result_events` 是 epoll_event 結構體的指標，它將指向的是所有已經準備好的事件描述符相關聯的 epoll_event（在上個步驟裡呼叫 epoll_ctl 時關聯起來的）。下面的例子可以讓你知道這個引數的意義。

`maxevents` 是返回的最大事件個數，也就是你能透過 result_events 指標遍歷到的最大的次數。

`timeout` 是等待超時的毫秒數。

用一個程式碼片段來展示 epoll 的用法：
    // 這個例子要監控檔案描述符 3, 4 的可讀狀態，以及 4, 5 的可寫狀態
    
    /* 透過 epoll_create 建立 epoll 描述符 */
    int epfd = epoll_create(4);
    
    int fd1 = 3;
    int fd2 = 4;
    int fd3 = 5;
    
    /* 透過 epoll_ctl 註冊好四個事件 */
    struct epoll_event ev1;
    ev1.events = EPOLLIN;      // 期待它的可讀事件發生
    ev1.data   = fd1;          // 我們通常就把 data 設定為 fd ，方便以後檢視
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd1, &ev1);  // 新增到事件表
    
    struct epoll_event ev2;
    ev2.events = EPOLLIN;
    ev2.data   = fd2;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd2, &ev2);
    
    struct epoll_event ev3;
    ev3.events = EPOLLOUT;     // 期待它的可寫事件發生
    ev3.data   = fd2;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd2, &ev3);
    
    struct epoll_event ev4;
    ev4.events = EPOLLOUT;
    ev4.data   = fd3;
    epoll_ctl(epfd, EPOLL_CTL_ADD, fd3, &ev4);
    
    /* 透過 epoll_wait 等待事件 */
    # DEFINE MAXEVENTS 4
    struct epoll_event result_events[MAXEVENTS];
    
    while(true){
        int n = epoll_wait(epfd, &result_events, MAXEVENTS, 5000);
    
        for(int i=0; i<n n--="" result_events="" ev1="" ev4="" if="" printf="" else="" epoll="" poll="" select="" epoll_ctl="" epoll_wait="" fd_set="" n="" fdarray="" i=""> 注 1 ：select/poll/epoll_wait 三個函式的等待超時時間都有一樣的特性：等待時間設定為 0 時函式不阻塞而是立即返回，不論是否有檔案描述符已準備好；poll/epoll_wait 中的 timeout 為 -1，select 中的 timeout 為 NULL 時，則無限等待，直到有描述符已準備好才會返回。

> 注 2 ：有的新手會把檔案描述符是否標記為阻塞 I/O 等同於 I/O 多路複用函式是否阻塞。其實檔案描述符是否標記為阻塞，決定了你 `read` 或 `write` 它時如果它未準備好是阻塞等待，還是立即返回 EAGAIN ；而 I/O 多路複用函式除非你把 timeout 設定為 0 ，否則它總是會阻塞住你的程式。

> 注 3 ：上面的例子只是入門，可能是不準確或不全面的：一是資料要立即處理防止丟失；二是 EPOLLIN/EPOLLOUT 不完全等同於可讀可寫事件，具體要去搜尋 poll/epoll 的事件具體有哪些；三是大多數實際例子裡，比如一個 tcp server ，都會在執行中不斷增加/刪除的檔案描述符而不是記住固定的 3 4 5 幾個描述符（用這種例子更能看出 epoll 的優勢）；四是 epoll 的優勢更多的體現在處理大量閒連線的情況，如果場景是處理少量短連線，用 select 反而更好，而且用 select 的程式碼能執行在所有平臺上。</n></sys></poll.h></maxfdp1></sys>

Java網路程式設計和NIO詳解6：Linux epoll實現原理詳解

相關文章