IO的同步非同步、阻塞非阻塞

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

另外一個阻塞解決方案是帶有阻塞通知的非阻塞 I/O。在這種模型中，配置的是非阻塞 I/O，然後使用阻塞 select 系統呼叫來確定一個 I/O 描述符何時有操作。使 select 呼叫非常有趣的是它可以用來為多個描述符提供通知，而不僅僅為一個描述符提供通知。對於每個提示符來說，我們可以請求這個描述符可以寫資料、有讀資料可用以及是否發生錯誤的通知。

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

select 呼叫的主要問題是它的效率不是非常高。儘管這是非同步通知使用的一種方便模型，但是對於高效能的 I/O 操作來說不建議使用。

非同步非阻塞 I/O（AIO）

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

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

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

下一節將深入介紹這種模型，探索這種模型使用的 API，然後展示幾個命令。

非同步 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 或


           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    IO操作中的同步/非同步、阻塞/非阻塞的含義
      
							
							
							前言

學好IO是java程式設計師從初級到高階進階學習的必經之路，像Netty這種優秀網路框架是必須要學習的，說到Netty就離不開java的IO模型，我們知道BIO、NIO、AIO分別是同步阻塞IO、同步非阻塞IO、非同步非阻塞IO，那麼這裡說的同步和非同步 

  
 

    

    
    從同步非同步、阻塞非阻塞到5種IO模型
      
							
							
							同步非同步、阻塞非阻塞



同步與非同步

同步與非同步在不同的場景下有不同的概念，在IO模型中的同步非同步，主要區別在當任務A呼叫任務B的過程中，程序A是否繼續進行。 
如果A等待B的結果，則為同步 
如果A不等待B的結果，則為非同步


同步狀態下任務A的 

  
 

    

    
    IO的同步非同步、阻塞非阻塞
      
                

AIO 簡介

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

  
 

    

    
    Java 同步/非同步IO,阻塞/非阻塞IO
       
 
 對於IO,有同步,非同步,阻塞,非阻塞的分類,最近才稍微對這些分類有一些理解,下面記錄一下: 
 首先，我們需要劃分IO，我們對IO操作分為兩個步驟，1：程式發出IO請求，2：完成實際IO操作，阻塞、非阻塞是針對第一步劃分的，而同步、非同步是針對第二部劃分的。 
 阻塞/非阻塞:首先,我覺得應該理解 

  
 

    

    
    解釋同步\非同步、阻塞\非阻塞、並行\併發之間的區別
      
                一、同步：執行一個操作之後，等待結果，然後才繼續執行後續的操作。非同步：執行一個操作後，可以去執行其他的操作，然後等待通知再回來執行剛才沒執行完的操作。

同步和非同步關注的是訊息通訊機制，所謂同步，就是在發出一個呼叫時，在沒有得到結果之前，該呼叫就不返回，但是一旦呼叫返回， 

  
 

    

    
    看完就明白什麼是同步/非同步、阻塞/非阻塞
      　　相信幹IT的或多或少都聽說過同步、非同步、阻塞、非阻塞這四個詞，它們也可以分成兩對，也就是同步、非同步一對，阻塞、非阻塞一對，這個看詞義就很好理解。關鍵問題在於同步和阻塞、非同步和非阻塞之間的區別，很多人對這兩組概念有點分不清，感覺意思差不多，其實它們描述的是兩個不同的問題，我們用一個具體的場景來描述一下 

  
 

    

    
    【併發程式設計】對阻塞/非阻塞、同步/非同步、併發/並行等基本概念的理解
      
							
							
							
1. 併發與並行

併發：concurrency 並行：parallelism

開發過程中，常常會接觸併發有關的概念，比如併發計算（concurrent computing），併發系統( concurrent system)，併發控制(concurrent  

  
 

    

    
    深入瞭解幾種IO模型（阻塞非阻塞，同步非同步）
      
                一般來說，Linux下系統IO主要就是通過以下幾個函式open(),close(),read(),write(),send(),recv(),lseek()，今天就以recv()為例來介紹下IO模型中的同步非同步，阻塞非阻塞的區別。先說阻塞與非阻塞的區別，recv()函式預設 

  
 

    

    
    Windows I/O模型、同步/非同步、阻塞/非阻塞
      
		
		
同步　　所謂同步，就是在發出一個功能呼叫時，在沒有得到結果之前，該呼叫就不返回。按照這個定義，其實絕大多數函式都是同步呼叫（例如sin, isdigit等）。但是一般而言，我們在說同步、非同步的時候，特指那些需要其他部件協作或者需要一定時間完成的任務。最常見的例子就是 SendMessag 

  
 

    

    
    一個例子理解同步-非同步、阻塞-非阻塞
       
 
 在程式設計進階中，往往很多程式設計師會碰到同步非同步，還有阻塞與非阻塞，這些概念往往容易混淆，下面我將通過一個例子來詳細說明他們之間的差別。 
 我們可以聯想這樣一個場景張三平時愛喝茶，現在他要去燒開水，即概括為： 
 張三，廢話不多說，煮開水。 
 出場人物：張三，水壺兩把（普通水壺，簡稱水壺；會 

  
 

    

    
    java 同步/非同步IO和阻塞/非阻塞IO 關係和概念解析
      
							
							
							I/O的模型

首先要宣告的一點一定要把同步/非同步 阻塞/非阻塞 以及I/O這三者的概念區別開來，同步大部分是阻塞 
的，非同步大部分是非阻塞的，但是它們之間並沒有必然的因果關係



同步與非同步

兩者產生需要有個前提——是否有多個任務或事件發生，只有滿足 

  
 

    

    
    IO模型介紹以及同步非同步阻塞非阻塞的區別
      
                

先說一下幾個單詞。

阻塞：使用者程序訪問資料時，如果未完成IO，等待IO操作完成或者進行系統呼叫來判斷IO是否完成
非阻塞：使用者程序訪問資料時，會馬上返回一個狀態值，無論是否完成

同步：使用者程序發起IO(就緒判斷)後，輪詢核心狀態
非同步：使用者程序發起IO後，可 

  
 

    

    
    同步非同步,阻塞非阻塞 和nginx的IO模型
      
                
http://www.cnblogs.com/wxl-dede/p/5134636.html
總結：一個IO操作基本包括兩個階段：
（1）等待資料準備就緒
（2）從核心向程序複製資料
如果是：
同步阻塞：那麼會一直阻塞下去。資料沒有就緒，那麼需要等待，拷貝資料也需要等待。
 

  
 

    

    
    同步非同步阻塞非阻塞Reactor模式和Proactor模式 （目前JAVA的NIO就屬於同步非阻塞IO）
      
                

在高效能的 I/O 設計中，有兩個比較著名的模式 Reactor 和 Proactor 模式，其中 Reactor 模式用於同步 I/O ，而 Proactor 運用於非同步 I/O 操作。

       在比較這兩個模式之前，我們首先的搞明白幾個概念，什麼是阻塞和非阻 

  
 

    

    
    python# 程序/執行緒/協程 # IO:同步/非同步/阻塞/非阻塞 #  greenlet gevent # 事件驅動與非同步IO # Select\Poll\Epoll非同步IO 以及selector
      
                
# 程序/執行緒/協程
# IO:同步/非同步/阻塞/非阻塞
#  greenlet gevent
# 事件驅動與非同步IO
# Select\Poll\Epoll非同步IO 以及selectors模組
# Python佇列/RabbitMQ佇列　　
########### 

  
 

    

    
    同步非同步、阻塞與非阻塞
      
                
阻塞：主要針對執行緒來說，跟蹤原始碼最終會發現執行緒wait在某個方法上，等待被喚醒。在訊息通訊中，表現為來了資料後解除阻塞，比如阻塞佇列模型中的notFull.await()/notEmpty.signal()和notEmpty.await()/notFull.signa 

  
 

    

    
    IO中同步非同步阻塞非阻塞的區別
      
                
更詳細解釋見http://yaocoder.blog.51cto.com/2668309/1308899
一、同步與非同步
同步/非同步, 它們是訊息的通知機制1. 概念解釋A. 同步所謂同步，就是在發出一個功能呼叫時，在沒有得到結果之前，該呼叫就不返回。按照這個定義，其實 

  
 

    

    
    同步非同步 阻塞非阻塞 Linux網路io模型
      
                一，概念描述同步與非同步#首先來解釋同步和非同步的概念，這兩個概念與訊息的通知機制有關。也就是同步與非同步主要是從訊息通知機制角度來說的。概念描述：所謂同步就是一個任務的完成需要依賴另外一個任務時，只有等待被依賴的任務完成後，依賴的任務才能算完成，這是一種可靠的任務序列。要麼 

  
 

    

    
    IO概念解析------同步異步阻塞非阻塞
      調用   net   阻塞   span   處理   過程   說明   例子   人做   各個IO Model的比較如圖所示：

阻塞和非阻塞強調的是程序在等待調用結果（消息，返回值）時的狀態.  阻塞調用是指調用結果返回之前，當前線程會被掛起。調用線程只有在得到結果之後才會返回。非阻塞調用指在不能立刻 

  
 

    

    
    同步非同步，阻塞非阻塞區別聯絡
       
 
 
   實際上同步與非同步是針對應用程式與核心的互動而言的。同步過程中程序觸發IO操作並等待(也就是我們說的阻塞)或者輪詢的去檢視IO操作(也就是我們說的非阻塞)是否完成。 非同步過程中程序觸發IO操作以後，直接返回，做自己的事情，IO交給核心來處理，完成後核心通知程序IO完成。