linux IO模型與AIO

AIO 簡介

Linux 異步 I/O 是 Linux 內核中提供的一個相當新的增強。它是 2.6 版本內核的一個標準特性，但是我們在 2.4 版本內核的補丁中也可以找到它。AIO 背後的基本思想是允許進程發起很多 I/O 操作，而不用阻塞或等待任何操作完成。稍後或在接收到 I/O 操作完成的通知時，進程就可以檢索 I/O 操作的結果。

I/O 模型

在深入介紹 AIO API 之前，讓我們先來探索一下 Linux 上可以使用的不同 I/O 模型。這並不是一個詳盡的介紹，但是我們將試圖介紹最常用的一些模型來解釋它們與異步 I/O 之間的區別。圖 1 給出了同步和異步模型，以及阻塞和非阻塞的模型。

圖 1. 基本 Linux I/O 模型的簡單矩陣

每個 I/O 模型都有自己的使用模式，它們對於特定的應用程序都有自己的優點。本節將簡要對其一一進行介紹。

同步阻塞 I/O

I/O 密集型與 CPU 密集型進程的比較

I/O 密集型進程所執行的 I/O 操作比執行的處理操作更多。CPU 密集型的進程所執行的處理操作比 I/O 操作更多。Linux 2.6 的調度器實際上更加偏愛 I/O 密集型的進程，因爲它們通常會發起一個 I/O 操作，然後進行阻塞，這就意味着其他工作都可以在兩者之間有效地交錯進行。

最常用的一個模型是同步阻塞 I/O 模型。在這個模型中，用戶空間的應用程序執行一個系統調用，這會導致應用程序阻塞。這意味着應用程序會一直阻塞，直到系統調用完成爲止（數據傳輸完成或發生錯誤）。調用應用程序處於一種不再消費 CPU 而只是簡單等待響應的狀態，因此從處理的角度來看，這是非常有效的。

圖 2 給出了傳統的阻塞 I/O 模型，這也是目前應用程序中最爲常用的一種模型。其行爲非常容易理解，其用法對於典型的應用程序來說都非常有效。在調用 read 系統調用時，應用程序會阻塞並對內核進行上下文切換。然後會觸發讀操作，當響應返回時（從我們正在從中讀取的設備中返回），數據就被移動到用戶空間的緩衝區中。然後應用程序就會解除阻塞（read 調用返回）。

圖 2. 同步阻塞 I/O 模型的典型流程

從應用程序的角度來說，read 調用會延續很長時間。實際上，在內核執行讀操作和其他工作時，應用程序的確會被阻塞。

同步非阻塞 I/O

同步阻塞 I/O 的一種效率稍低的變種是同步非阻塞 I/O。在這種模型中，設備是以非阻塞的形式打開的。這意味着 I/O 操作不會立即完成，read操作可能會返回一個錯誤代碼，說明這個命令不能立即滿足（EAGAIN 或 EWOULDBLOCK），如圖 3 所示。

圖 3. 同步非阻塞 I/O 模型的典型流程

非阻塞的實現是 I/O 命令可能並不會立即滿足，需要應用程序調用許多次來等待操作完成(簡單地說就是輪詢)。這可能效率不高，因爲在很多情況下，當內核執行這個命令時，應用程序必須要進行忙碌等待，直到數據可用爲止，或者試圖執行其他工作。正如圖 3 所示的一樣，這個方法可以引入 I/O 操作的延時，因爲數據在內核中變爲可用到用戶調用 read 返回數據之間存在一定的間隔，這會導致整體數據吞吐量的降低。

異步阻塞 I/O

另外一個阻塞解決方案是IO多路複用(複用的select線程)。I/O複用模型會用到select、poll、epoll函數，這幾個函數也會使進程阻塞，但是和阻塞I/O所不同的的，這兩個函數可以同時阻塞多個I/O操作。而且可以同時對多個讀操作，多個寫操作的I/O函數進行檢測，直到有數據可讀或可寫時，才真正調用I/O操作函數。對於每個提示符來說，我們可以獲取這個描述符可以寫數據、有讀數據可用以及是否發生錯誤的通知。

圖 4. 異步阻塞 I/O 模型的典型流程 (select)




epoll跟select都能提供多路I/O複用的解決方案。在現在的Linux內核裏有都能夠支持，其中epoll是Linux所特有，而select則應該是POSIX所規定，一般操作系統均有實現.

select 調用的主要問題是它的效率不是非常高。儘管這是異步通知使用的一種方便模型，但是對socket進行掃描時是線性掃描，即採用輪詢的方法，效率較低,對於高性能的 I/O 操作來說不建議使用。而且需要維護一個用來存放大量fd的數據結構，這樣會使得用戶空間和內核空間在傳遞該結構時複製開銷大.

poll本質上和select沒有區別，它將用戶傳入的數組拷貝到內核空間，然後查詢每個fd對應的設備狀態，如果設備就緒則在設備等待隊列中加入一項並繼續遍歷，如果遍歷完所有fd後沒有發現就緒設備，則掛起當前進程，直到設備就緒或者主動超時，被喚醒後它又要再次遍歷fd。這個過程經歷了多次無謂的遍歷.它沒有最大連接數的限制，原因是它是基於鏈表來存儲的，但是同樣有一個缺點:大量的fd的數組被整體複製於用戶態和內核地址空間之間. poll還有一個特點是“水平觸發”，如果報告了fd後，沒有被處理，那麼下次poll時會再次報告該fd。

epoll支持水平觸發和邊緣觸發，最大的特點在於邊緣觸發，它只告訴進程哪些fd剛剛變爲就需態，並且只會通知一次。還有一個特點是，epoll使用“事件”的就緒通知方式，通過epoll_ctl註冊fd，一旦該fd就緒，內核就會採用類似callback的回調機制來激活該fd，epoll_wait便可以收到通知.1. 沒有最大併發連接的限制，能打開的FD的上限遠大於1024（1G的內存上能監聽約10萬個端口）2. 效率提升，不是輪詢的方式,只管你“活躍”的連接，不會隨着FD數目的增加效率下降。只有活躍可用的FD纔會調用callback函數 3. 內存拷貝，利用mmap()文件映射內存加速與內核空間的消息傳遞；即epoll使用mmap減少複製開銷.

BUT: 表面上看epoll的性能最好，但是在連接數少並且連接都十分活躍的情況下，select和poll的性能可能比epoll好，畢竟epoll的通知機制需要很多函數回調。

異步非阻塞 I/O（AIO）

最後，異步非阻塞 I/O 模型是一種CPU處理與 I/O 重疊進行的模型。讀請求會立即返回，說明 read 請求已經成功發起了。在後臺完成讀操作時，應用程序然後會執行其他處理操作。當 read 的響應到達時，就會產生一個信號或執行一個基於線程的回調函數來完成這次 I/O 處理過程。

圖 5. 異步非阻塞 I/O 模型的典型流程

在一個進程中爲了執行多個 I/O 請求,利用CPU處理速度與 I/O 速度之間的差異, 而對CPU計算操作和 I/O 處理進行重疊處理。當一個或多個 I/O 請求掛起時，CPU 可以執行其他任務；或者更爲常見的是，在發起其他 I/O 的同時對已經完成的 I/O 進行操作。

異步 I/O 的動機

從前面 I/O 模型的分類中，我們可以看出 AIO 的動機。阻塞模型需要在 I/O 操作開始時阻塞應用程序。這意味着不可能同時重疊進行處理和 I/O 操作。同步非阻塞模型允許處理和 I/O 操作重疊進行，但是這需要應用程序根據重現的規則來檢查 I/O 操作的狀態。這樣就剩下異步非阻塞 I/O 了，它允許處理和 I/O 操作重疊進行，包括 I/O 操作完成的通知。

select 函數所提供的功能（異步阻塞 I/O）與 AIO 類似。不過，它是對通知事件進行阻塞，而不是對 I/O 調用進行阻塞。

Linux 上的 AIO 簡介

本節將探索 Linux 的異步 I/O 模型，從而幫助我們理解如何在應用程序中使用這種技術。

在傳統的 I/O 模型中，有一個使用惟一句柄標識的 I/O 通道。在 UNIX® 中，這些句柄是文件描述符（這對等同於文件、管道、套接字等等）。在阻塞 I/O 中，我們發起了一次傳輸操作，當傳輸操作完成或發生錯誤時，系統調用就會返回。

Linux 上的 AIO

AIO 在 2.5 版本的內核中首次出現，現在已經是 2.6 版本的產品內核的一個標準特性了。

在異步非阻塞 I/O 中，我們可以同時發起多個傳輸操作。這需要每個傳輸操作都有惟一的上下文，這樣我們才能在它們完成時區分到底是哪個傳輸操作完成了。在 AIO 中，這是一個 aiocb（AIO I/O Control Block）結構。這個結構包含了有關傳輸的所有信息，包括爲數據準備的用戶緩衝區。在產生 I/O （稱爲完成）通知時，aiocb 結構就被用來惟一標識所完成的 I/O 操作。這個 API 的展示顯示瞭如何使用它。

AIO API

AIO 接口的 API 非常簡單，但是它爲數據傳輸提供了必需的功能，並給出了兩個不同的通知模型。表 1 給出了 AIO 的接口函數，本節稍後會更詳細進行介紹。

表 1. AIO 接口 API

API 函數	說明
aio_read	請求異步讀操作
aio_error	檢查異步請求的狀態
aio_return	獲得完成的異步請求的返回狀態
aio_write	請求異步寫操作
aio_suspend	掛起調用進程，直到一個或多個異步請求已經完成（或失敗）
aio_cancel	取消異步 I/O 請求
lio_listio	發起一系列 I/O 操作

每個 API 函數都使用 aiocb 結構開始或檢查。這個結構有很多元素，但是清單 1 僅僅給出了需要（或可以）使用的元素。

清單 1. aiocb 結構中相關的域

struct aiocb {

  int aio_fildes;               // File Descriptor
  int aio_lio_opcode;           // Valid only for lio_listio (r/w/nop)
  volatile void *aio_buf;       // Data Buffer
  size_t aio_nbytes;            // Number of Bytes in Data Buffer
  struct sigevent aio_sigevent; // Notification Structure

  /* Internal fields */
  ...

};

sigevent 結構告訴 AIO 在 I/O 操作完成時應該執行什麼操作。我們將在 AIO 的展示中對這個結構進行探索。現在我們將展示各個 AIO 的 API 函數是如何工作的，以及我們應該如何使用它們。

aio_read

aio_read 函數請求對一個有效的文件描述符進行異步讀操作。這個文件描述符可以表示一個文件、套接字甚至管道。aio_read 函數的原型如下：

int aio_read( struct aiocb *aiocbp );

aio_read 函數在請求進行排隊之後會立即返回。如果執行成功，返回值就爲 0；如果出現錯誤，返回值就爲 -1，並設置 errno 的值。

要執行讀操作，應用程序必須對 aiocb 結構進行初始化。下面這個簡短的例子就展示瞭如何填充 aiocb 請求結構，並使用 aio_read 來執行異步讀請求（現在暫時忽略通知）操作。它還展示了 aio_error 的用法，不過我們將稍後再作解釋。

清單 2. 使用 aio_read 進行異步讀操作的例子

#include <aio.h>

...

  int fd, ret;
  struct aiocb my_aiocb;

  fd = open( "file.txt", O_RDONLY );
  if (fd < 0) perror("open");

  /* Zero out the aiocb structure (recommended) */
  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );

  /* Allocate a data buffer for the aiocb request */
  my_aiocb.aio_buf = malloc(BUFSIZE+1);
  if (!my_aiocb.aio_buf) perror("malloc");

  /* Initialize the necessary fields in the aiocb */
  my_aiocb.aio_fildes = fd;
  my_aiocb.aio_nbytes = BUFSIZE;
  my_aiocb.aio_offset = 0;

  ret = aio_read( &my_aiocb );
  if (ret < 0) perror("aio_read");

  while ( aio_error( &my_aiocb ) == EINPROGRESS ) ;

  if ((ret = aio_return( &my_iocb )) > 0) {
    /* got ret bytes on the read */
  } else {
    /* read failed, consult errno */
  }

在清單 2 中，在打開要從中讀取數據的文件之後，我們就清空了 aiocb 結構，然後分配一個數據緩衝區。並將對這個數據緩衝區的引用放到 aio_buf 中。然後，我們將 aio_nbytes 初始化成緩衝區的大小。並將 aio_offset 設置成 0（該文件中的第一個偏移量）。我們將 aio_fildes 設置爲從中讀取數據的文件描述符。在設置這些域之後，就調用 aio_read 請求進行讀操作。我們然後可以調用 aio_error 來確定 aio_read 的狀態。只要狀態是 EINPROGRESS，就一直忙碌等待，直到狀態發生變化爲止。現在，請求可能成功，也可能失敗。

使用 AIO 接口來編譯程序

我們可以在 aio.h 頭文件中找到函數原型和其他需要的符號。在編譯使用這種接口的程序時，我們必須使用 POSIX 實時擴展庫（librt）。

注意使用這個 API 與標準的庫函數從文件中讀取內容是非常相似的。除了 aio_read 的一些異步特性之外，另外一個區別是讀操作偏移量的設置。在傳統的 read 調用中，偏移量是在文件描述符上下文中進行維護的。對於每個讀操作來說，偏移量都需要進行更新，這樣後續的讀操作才能對下一塊數據進行尋址。對於異步 I/O 操作來說這是不可能的，因爲我們可以同時執行很多讀請求，因此必須爲每個特定的讀請求都指定偏移量。

aio_error

aio_error 函數被用來確定請求的狀態。其原型如下：

int aio_error( struct aiocb *aiocbp );

這個函數可以返回以下內容：

• EINPROGRESS，說明請求尚未完成
• ECANCELLED，說明請求被應用程序取消了
• -1，說明發生了錯誤，具體錯誤原因可以查閱 errno

aio_return

異步 I/O 和標準塊 I/O 之間的另外一個區別是我們不能立即訪問這個函數的返回狀態，因爲我們並沒有阻塞在 read 調用上。在標準的 read 調用中，返回狀態是在該函數返回時提供的。但是在異步 I/O 中，我們要使用 aio_return 函數。這個函數的原型如下：

ssize_t aio_return( struct aiocb *aiocbp );

只有在 aio_error 調用確定請求已經完成（可能成功，也可能發生了錯誤）之後，纔會調用這個函數。aio_return 的返回值就等價於同步情況中 read 或 write 系統調用的返回值（所傳輸的字節數，如果發生錯誤，返回值就爲 -1）。

aio_write

aio_write 函數用來請求一個異步寫操作。其函數原型如下：

int aio_write( struct aiocb *aiocbp );

aio_write 函數會立即返回，說明請求已經進行排隊（成功時返回值爲 0，失敗時返回值爲 -1，並相應地設置 errno）。

這與 read 系統調用類似，但是有一點不一樣的行爲需要注意。回想一下對於 read 調用來說，要使用的偏移量是非常重要的。然而，對於 write 來說，這個偏移量只有在沒有設置 O_APPEND 選項的文件上下文中才會非常重要。如果設置了 O_APPEND，那麼這個偏移量就會被忽略，數據都會被附加到文件的末尾。否則，aio_offset 域就確定了數據在要寫入的文件中的偏移量。

aio_suspend

我們可以使用 aio_suspend 函數來掛起（或阻塞）調用進程，直到異步請求完成爲止，此時會產生一個信號，或者發生其他超時操作。調用者提供了一個 aiocb 引用列表，其中任何一個完成都會導致 aio_suspend 返回。 aio_suspend 的函數原型如下：

int aio_suspend( const struct aiocb *const cblist[],
                  int n, const struct timespec *timeout );

aio_suspend 的使用非常簡單。我們要提供一個 aiocb 引用列表。如果任何一個完成了，這個調用就會返回 0。否則就會返回 -1，說明發生了錯誤。請參看清單 3。

清單 3. 使用 aio_suspend 函數阻塞異步 I/O

struct aioct *cblist[MAX_LIST]

/* Clear the list. */
bzero( (char *)cblist, sizeof(cblist) );

/* Load one or more references into the list */
cblist[0] = &my_aiocb;

ret = aio_read( &my_aiocb );

ret = aio_suspend( cblist, MAX_LIST, NULL );

注意，aio_suspend 的第二個參數是 cblist 中元素的個數，而不是 aiocb 引用的個數。cblist 中任何 NULL 元素都會被 aio_suspend 忽略。

如果爲 aio_suspend 提供了超時，而超時情況的確發生了，那麼它就會返回 -1，errno 中會包含 EAGAIN。

aio_cancel

aio_cancel 函數允許我們取消對某個文件描述符執行的一個或所有 I/O 請求。其原型如下：

int aio_cancel( int fd, struct aiocb *aiocbp );

要取消一個請求，我們需要提供文件描述符和 aiocb 引用。如果這個請求被成功取消了，那麼這個函數就會返回 AIO_CANCELED。如果請求完成了，這個函數就會返回 AIO_NOTCANCELED。

要取消對某個給定文件描述符的所有請求，我們需要提供這個文件的描述符，以及一個對 aiocbp 的 NULL 引用。如果所有的請求都取消了，這個函數就會返回 AIO_CANCELED；如果至少有一個請求沒有被取消，那麼這個函數就會返回 AIO_NOT_CANCELED；如果沒有一個請求可以被取消，那麼這個函數就會返回 AIO_ALLDONE。我們然後可以使用 aio_error 來驗證每個 AIO 請求。如果這個請求已經被取消了，那麼 aio_error 就會返回 -1，並且 errno 會被設置爲 ECANCELED。

lio_listio

最後，AIO 提供了一種方法使用 lio_listio API 函數同時發起多個傳輸。這個函數非常重要，因爲這意味着我們可以在一個系統調用（一次內核上下文切換）中啓動大量的 I/O 操作。從性能的角度來看，這非常重要，因此值得我們花點時間探索一下。lio_listio API 函數的原型如下：

int lio_listio( int mode, struct aiocb *list[], int nent,
                   struct sigevent *sig );

mode 參數可以是 LIO_WAIT 或 LIO_NOWAIT。LIO_WAIT 會阻塞這個調用，直到所有的 I/O 都完成爲止。在操作進行排隊之後，LIO_NOWAIT就會返回。list 是一個 aiocb 引用的列表，最大元素的個數是由 nent 定義的。注意 list 的元素可以爲 NULL，lio_listio 會將其忽略。sigevent 引用定義了在所有 I/O 操作都完成時產生信號的方法。

對於 lio_listio 的請求與傳統的 read 或 write 請求在必須指定的操作方面稍有不同，如清單 4 所示。

清單 4. 使用 lio_listio 函數發起一系列請求

struct aiocb aiocb1, aiocb2;
struct aiocb *list[MAX_LIST];

...

/* Prepare the first aiocb */
aiocb1.aio_fildes = fd;
aiocb1.aio_buf = malloc( BUFSIZE+1 );
aiocb1.aio_nbytes = BUFSIZE;
aiocb1.aio_offset = next_offset;
aiocb1.aio_lio_opcode = LIO_READ;

...

bzero( (char *)list, sizeof(list) );
list[0] = &aiocb1;
list[1] = &aiocb2;

ret = lio_listio( LIO_WAIT, list, MAX_LIST, NULL );

對於讀操作來說，aio_lio_opcode 域的值爲 LIO_READ。對於寫操作來說，我們要使用 LIO_WRITE，不過 LIO_NOP 對於不執行操作來說也是有效的。

AIO 通知

現在我們已經看過了可用的 AIO 函數，本節將深入介紹對異步通知可以使用的方法。我們將通過信號和函數回調來探索異步函數的通知機制。

使用信號進行異步通知

使用信號進行進程間通信（IPC）是 UNIX 中的一種傳統機制，AIO 也可以支持這種機制。在這種範例中，應用程序需要定義信號處理程序，在產生指定的信號時就會調用這個處理程序。應用程序然後配置一個異步請求將在請求完成時產生一個信號。作爲信號上下文的一部分，特定的 aiocb 請求被提供用來記錄多個可能會出現的請求。清單 5 展示了這種通知方法。

清單 5. 使用信號作爲 AIO 請求的通知

void setup_io( ... )
{
  int fd;
  struct sigaction sig_act;
  struct aiocb my_aiocb;

  ...

  /* Set up the signal handler */
  sigemptyset(&sig_act.sa_mask);
  sig_act.sa_flags = SA_SIGINFO;
  sig_act.sa_sigaction = aio_completion_handler;


  /* Set up the AIO request */
  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
  my_aiocb.aio_fildes = fd;
  my_aiocb.aio_buf = malloc(BUF_SIZE+1);
  my_aiocb.aio_nbytes = BUF_SIZE;
  my_aiocb.aio_offset = next_offset;

  /* Link the AIO request with the Signal Handler */
  my_aiocb.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
  my_aiocb.aio_sigevent.sigev_signo = SIGIO;
  my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;

  /* Map the Signal to the Signal Handler */
  ret = sigaction( SIGIO, &sig_act, NULL );

  ...

  ret = aio_read( &my_aiocb );

}


void aio_completion_handler( int signo, siginfo_t *info, void *context )
{
  struct aiocb *req;


  /* Ensure it's our signal */
  if (info->si_signo == SIGIO) {

    req = (struct aiocb *)info->si_value.sival_ptr;

    /* Did the request complete? */
    if (aio_error( req ) == 0) {

      /* Request completed successfully, get the return status */
      ret = aio_return( req );

    }

  }

  return;
}

在清單 5 中，我們在 aio_completion_handler 函數中設置信號處理程序來捕獲 SIGIO 信號。然後初始化 aio_sigevent 結構產生 SIGIO信號來進行通知（這是通過 sigev_notify 中的 SIGEV_SIGNAL 定義來指定的）。當讀操作完成時，信號處理程序就從該信號的 si_value 結構中提取出 aiocb，並檢查錯誤狀態和返回狀態來確定 I/O 操作是否完成。

對於性能來說，這個處理程序也是通過請求下一次異步傳輸而繼續進行 I/O 操作的理想地方。採用這種方式，在一次數據傳輸完成時，我們就可以立即開始下一次數據傳輸操作。

使用回調函數進行異步通知

另外一種通知方式是系統回調函數。這種機制不會爲通知而產生一個信號，而是會調用用戶空間的一個函數來實現通知功能。我們在 sigevent結構中設置了對 aiocb 的引用，從而可以惟一標識正在完成的特定請求。請參看清單 6。

清單 6. 對 AIO 請求使用線程回調通知

void setup_io( ... )
{
  int fd;
  struct aiocb my_aiocb;

  ...

  /* Set up the AIO request */
  bzero( (char *)&my_aiocb, sizeof(struct aiocb) );
  my_aiocb.aio_fildes = fd;
  my_aiocb.aio_buf = malloc(BUF_SIZE+1);
  my_aiocb.aio_nbytes = BUF_SIZE;
  my_aiocb.aio_offset = next_offset;

  /* Link the AIO request with a thread callback */
  my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;
  my_aiocb.aio_sigevent.notify_function = aio_completion_handler;
  my_aiocb.aio_sigevent.notify_attributes = NULL;
  my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;

  ...

  ret = aio_read( &my_aiocb );

}


void aio_completion_handler( sigval_t sigval )
{
  struct aiocb *req;

  req = (struct aiocb *)sigval.sival_ptr;

  /* Did the request complete? */
  if (aio_error( req ) == 0) {

    /* Request completed successfully, get the return status */
    ret = aio_return( req );

  }

  return;
}

在清單 6 中，在創建自己的 aiocb 請求之後，我們使用 SIGEV_THREAD 請求了一個線程回調函數來作爲通知方法。然後我們將指定特定的通知處理程序，並將要傳輸的上下文加載到處理程序中（在這種情況中，是個對 aiocb 請求自己的引用）。在這個處理程序中，我們簡單地引用到達的 sigval 指針並使用 AIO 函數來驗證請求已經完成。

對 AIO 進行系統優化

proc 文件系統包含了兩個虛擬文件，它們可以用來對異步 I/O 的性能進行優化：

• /proc/sys/fs/aio-nr 文件提供了系統範圍異步 I/O 請求現在的數目。
• /proc/sys/fs/aio-max-nr 文件是所允許的併發請求的最大個數。最大個數通常是 64KB，這對於大部分應用程序來說都已經足夠了。

結束語

使用異步 I/O 可以幫助我們構建 I/O 速度更快、效率更高的應用程序。如果我們的應用程序可以對處理和 I/O 操作重疊進行，那麼 AIO 就可以幫助我們構建可以更高效地使用可用 CPU 資源的應用程序。儘管這種 I/O 模型與在大部分 Linux 應用程序中使用的傳統阻塞模式都不同，但是異步通知模型在概念上來說卻非常簡單，可以簡化我們的設計。

本文在原文基礎上小施改動,尊重原創.

原文地址:https://www.ibm.com/developerworks/cn/linux/l-async/