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 操作都完成時產生訊號的方法。
對於
前言
學好IO是java程式設計師從初級到高階進階學習的必經之路,像Netty這種優秀網路框架是必須要學習的,說到Netty就離不開java的IO模型,我們知道BIO、NIO、AIO分別是同步阻塞IO、同步非阻塞IO、非同步非阻塞IO,那麼這裡說的同步和非同步
同步非同步、阻塞非阻塞
同步與非同步
同步與非同步在不同的場景下有不同的概念,在IO模型中的同步非同步,主要區別在當任務A呼叫任務B的過程中,程序A是否繼續進行。
如果A等待B的結果,則為同步
如果A不等待B的結果,則為非同步
同步狀態下任務A的
AIO 簡介
Linux 非同步 I/O 是 Linux 核心中提供的一個相當新的增強。它是 2.6 版本核心的一個標準特性,但是我們在 2.4 版本核心的補丁中也可以找到它。AIO 背後的基本思想是允許程序發起很多 I/O 操作,而不用阻塞或等待任何操作完成。稍後或在
對於IO,有同步,非同步,阻塞,非阻塞的分類,最近才稍微對這些分類有一些理解,下面記錄一下:
首先,我們需要劃分IO,我們對IO操作分為兩個步驟,1:程式發出IO請求,2:完成實際IO操作,阻塞、非阻塞是針對第一步劃分的,而同步、非同步是針對第二部劃分的。
阻塞/非阻塞:首先,我覺得應該理解
一、同步:執行一個操作之後,等待結果,然後才繼續執行後續的操作。非同步:執行一個操作後,可以去執行其他的操作,然後等待通知再回來執行剛才沒執行完的操作。
同步和非同步關注的是訊息通訊機制,所謂同步,就是在發出一個呼叫時,在沒有得到結果之前,該呼叫就不返回,但是一旦呼叫返回, 相信幹IT的或多或少都聽說過同步、非同步、阻塞、非阻塞這四個詞,它們也可以分成兩對,也就是同步、非同步一對,阻塞、非阻塞一對,這個看詞義就很好理解。關鍵問題在於同步和阻塞、非同步和非阻塞之間的區別,很多人對這兩組概念有點分不清,感覺意思差不多,其實它們描述的是兩個不同的問題,我們用一個具體的場景來描述一下
1. 併發與並行
併發:concurrency 並行:parallelism
開發過程中,常常會接觸併發有關的概念,比如併發計算(concurrent computing),併發系統( concurrent system),併發控制(concurrent
一般來說,Linux下系統IO主要就是通過以下幾個函式open(),close(),read(),write(),send(),recv(),lseek(),今天就以recv()為例來介紹下IO模型中的同步非同步,阻塞非阻塞的區別。先說阻塞與非阻塞的區別,recv()函式預設
同步 所謂同步,就是在發出一個功能呼叫時,在沒有得到結果之前,該呼叫就不返回。按照這個定義,其實絕大多數函式都是同步呼叫(例如sin, isdigit等)。但是一般而言,我們在說同步、非同步的時候,特指那些需要其他部件協作或者需要一定時間完成的任務。最常見的例子就是 SendMessag
在程式設計進階中,往往很多程式設計師會碰到同步非同步,還有阻塞與非阻塞,這些概念往往容易混淆,下面我將通過一個例子來詳細說明他們之間的差別。
我們可以聯想這樣一個場景張三平時愛喝茶,現在他要去燒開水,即概括為:
張三,廢話不多說,煮開水。
出場人物:張三,水壺兩把(普通水壺,簡稱水壺;會
I/O的模型
首先要宣告的一點一定要把同步/非同步 阻塞/非阻塞 以及I/O這三者的概念區別開來,同步大部分是阻塞
的,非同步大部分是非阻塞的,但是它們之間並沒有必然的因果關係
同步與非同步
兩者產生需要有個前提——是否有多個任務或事件發生,只有滿足
先說一下幾個單詞。
阻塞:使用者程序訪問資料時,如果未完成IO,等待IO操作完成或者進行系統呼叫來判斷IO是否完成
非阻塞:使用者程序訪問資料時,會馬上返回一個狀態值,無論是否完成
同步:使用者程序發起IO(就緒判斷)後,輪詢核心狀態
非同步:使用者程序發起IO後,可
http://www.cnblogs.com/wxl-dede/p/5134636.html
總結:一個IO操作基本包括兩個階段:
(1)等待資料準備就緒
(2)從核心向程序複製資料
如果是:
同步阻塞:那麼會一直阻塞下去。資料沒有就緒,那麼需要等待,拷貝資料也需要等待。
在高效能的 I/O 設計中,有兩個比較著名的模式 Reactor 和 Proactor 模式,其中 Reactor 模式用於同步 I/O ,而 Proactor 運用於非同步 I/O 操作。
在比較這兩個模式之前,我們首先的搞明白幾個概念,什麼是阻塞和非阻
# 程序/執行緒/協程
# IO:同步/非同步/阻塞/非阻塞
# greenlet gevent
# 事件驅動與非同步IO
# Select\Poll\Epoll非同步IO 以及selectors模組
# Python佇列/RabbitMQ佇列
###########
阻塞:主要針對執行緒來說,跟蹤原始碼最終會發現執行緒wait在某個方法上,等待被喚醒。在訊息通訊中,表現為來了資料後解除阻塞,比如阻塞佇列模型中的notFull.await()/notEmpty.signal()和notEmpty.await()/notFull.signa
更詳細解釋見http://yaocoder.blog.51cto.com/2668309/1308899
一、同步與非同步
同步/非同步, 它們是訊息的通知機制1. 概念解釋A. 同步所謂同步,就是在發出一個功能呼叫時,在沒有得到結果之前,該呼叫就不返回。按照這個定義,其實
一,概念描述同步與非同步#首先來解釋同步和非同步的概念,這兩個概念與訊息的通知機制有關。也就是同步與非同步主要是從訊息通知機制角度來說的。概念描述:所謂同步就是一個任務的完成需要依賴另外一個任務時,只有等待被依賴的任務完成後,依賴的任務才能算完成,這是一種可靠的任務序列。要麼 調用 net 阻塞 span 處理 過程 說明 例子 人做 各個IO Model的比較如圖所示:
阻塞和非阻塞強調的是程序在等待調用結果(消息,返回值)時的狀態. 阻塞調用是指調用結果返回之前,當前線程會被掛起。調用線程只有在得到結果之後才會返回。非阻塞調用指在不能立刻
實際上同步與非同步是針對應用程式與核心的互動而言的。同步過程中程序觸發IO操作並等待(也就是我們說的阻塞)或者輪詢的去檢視IO操作(也就是我們說的非阻塞)是否完成。 非同步過程中程序觸發IO操作以後,直接返回,做自己的事情,IO交給核心來處理,完成後核心通知程序IO完成。 lio_listio
的請求與傳統的 read
或
相關推薦
IO操作中的同步/非同步、阻塞/非阻塞的含義
從同步非同步、阻塞非阻塞到5種IO模型
IO的同步非同步、阻塞非阻塞
Java 同步/非同步IO,阻塞/非阻塞IO
解釋同步\非同步、阻塞\非阻塞、並行\併發之間的區別
看完就明白什麼是同步/非同步、阻塞/非阻塞
【併發程式設計】對阻塞/非阻塞、同步/非同步、併發/並行等基本概念的理解
深入瞭解幾種IO模型(阻塞非阻塞,同步非同步)
Windows I/O模型、同步/非同步、阻塞/非阻塞
一個例子理解同步-非同步、阻塞-非阻塞
java 同步/非同步IO和阻塞/非阻塞IO 關係和概念解析
IO模型介紹以及同步非同步阻塞非阻塞的區別
同步非同步,阻塞非阻塞 和nginx的IO模型
同步非同步阻塞非阻塞Reactor模式和Proactor模式 (目前JAVA的NIO就屬於同步非阻塞IO)
python# 程序/執行緒/協程 # IO:同步/非同步/阻塞/非阻塞 # greenlet gevent # 事件驅動與非同步IO # Select\Poll\Epoll非同步IO 以及selector
同步非同步、阻塞與非阻塞
IO中同步非同步阻塞非阻塞的區別
同步非同步 阻塞非阻塞 Linux網路io模型
IO概念解析------同步異步阻塞非阻塞
同步非同步,阻塞非阻塞區別聯絡