一、I/O模型

IO在計算機中指Input/Output，也就是輸入和輸出。由于程序和運行時數(shù)據(jù)是在內存中駐留，由CPU這個超快的計算核心來執(zhí)行，涉及到數(shù)據(jù)交換的地方，通常是磁盤、網(wǎng)絡等，就需要IO接口。

同步（synchronous） IO和異步（asynchronous） IO，阻塞（blocking） IO和非阻塞（non-blocking）IO分別是什么，到底有什么區(qū)別？

這個問題其實不同的人給出的答案都可能不同，比如wiki，就認為asynchronous IO和non-blocking IO是一個東西。這其實是因為不同的人的知識背景不同，并且在討論這個問題的時候上下文(context)也不相同。所以，為了更好的回答這個問題，先限定一下本文的上下文。
本文討論的背景是Linux環(huán)境下的network IO。

Stevens在文章中一共比較了五種IO Model：

blocking IO（阻塞IO）

nonblocking IO （非阻塞IO）

IO multiplexing （IO多路復用）

asynchronous IO （異步IO）

signal driven IO （信號驅動IO）

由于signal driven IO在實際中并不常用，所以我這只提及剩下的四種IO Model。

再說一下IO發(fā)生時涉及的對象和步驟。

對于一個network IO (這里我們以read舉例)，它會涉及到兩個系統(tǒng)對象，一個是調用這個IO的process (or thread)，另一個就是系統(tǒng)內核(kernel)。當一個read操作發(fā)生時，它會經歷兩個階段：

等待數(shù)據(jù)準備 (Waiting for the data to be ready)
將數(shù)據(jù)從內核拷貝到進程中 (Copying the data from the kernel to the process)
記住這兩點很重要，因為這些IO Model的區(qū)別就是在兩個階段上各有不同的情況。

二、 blocking IO

在linux中，默認情況下所有的socket都是blocking，一個典型的讀操作流程大概是這樣：

當用戶進程調用了recvfrom這個系統(tǒng)調用，kernel就開始了IO的第一個階段：準備數(shù)據(jù)。對于network IO來說，很多時候數(shù)據(jù)在一開始還沒有到達（比如，還沒有收到一個完整的UDP包），這個時候kernel就要等待足夠的數(shù)據(jù)到來。而在用戶進程這邊，整個進程會被阻塞。當kernel一直等到數(shù)據(jù)準備好了，它就會將數(shù)據(jù)從kernel中拷貝到用戶內存，然后kernel返回結果，用戶進程才解除block的狀態(tài)，重新運行起來。

所以，blocking IO的特點就是在IO執(zhí)行的兩個階段都被block了。

三、non-blocking IO

linux下，可以通過設置socket使其變?yōu)閚on-blocking。當對一個non-blocking socket執(zhí)行讀操作時，流程是這個樣子：

從圖中可以看出，當用戶進程發(fā)出read操作時，如果kernel中的數(shù)據(jù)還沒有準備好，那么它并不會block用戶進程，而是立刻返回一個error。從用戶進程角度講 ，它發(fā)起一個read操作后，并不需要等待，而是馬上就得到了一個結果。用戶進程判斷結果是一個error時，它就知道數(shù)據(jù)還沒有準備好，于是它可以再次發(fā)送read操作。一旦kernel中的數(shù)據(jù)準備好了，并且又再次收到了用戶進程的system call，那么它馬上就將數(shù)據(jù)拷貝到了用戶內存，然后返回。所以，用戶進程其實是需要不斷的主動詢問kernel數(shù)據(jù)好了沒有。

注意：

在網(wǎng)絡IO時候，非阻塞IO也會進行recvform系統(tǒng)調用，檢查數(shù)據(jù)是否準備好，與阻塞IO不一樣，”非阻塞將大的整片時間的阻塞分成N多的小的阻塞, 所以進程不斷地有機會 ‘被' CPU光顧”。即每次recvform系統(tǒng)調用之間，cpu的權限還在進程手中，這段時間是可以做其他事情的，也就是說非阻塞的recvform系統(tǒng)調用之后，進程并沒有被阻塞，內核馬上返回給進程，如果數(shù)據(jù)還沒準備好，此時會返回一個error。進程在返回之后，可以干點別的事情，然后再發(fā)起recvform系統(tǒng)調用。重復上面的過程，循環(huán)往復的進行recvform系統(tǒng)調用。這個過程通常被稱之為輪詢。輪詢檢查內核數(shù)據(jù)，直到數(shù)據(jù)準備好，再拷貝數(shù)據(jù)到進程，進行數(shù)據(jù)處理。需要注意，拷貝數(shù)據(jù)整個過程，進程仍然是屬于阻塞的狀態(tài)。

import time
import socket

sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1', 8080))
sk.listen(5)
sk.setblocking(False)  #設置套接字為非阻塞模式
while True:
  try:
    print('waiting client connection .......')
    connection, address = sk.accept() # 進程主動輪詢
    print("+++", address)
    client_messge = connection.recv(1024)
    print(str(client_messge, 'utf8'))
    connection.close()
  except Exception as e:
    print(e)
    time.sleep(4)

#############################client

import time
import socket
sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

while True:
  sk.connect(('127.0.0.1', 8080))
  print("hello")
  sk.sendall(bytes("hello", "utf8"))
  time.sleep(2)
  break

以上實例，服務段端每隔4秒輪詢一次，若沒有任何客戶端鏈接，則會拋出錯誤信息，并繼續(xù)輪詢。

非阻塞IO：

優(yōu)點：能夠在等待任務完成的時間里干其他活了（包括提交其他任務，也就是 “后臺” 可以有多個任務在同時執(zhí)行）。

缺點：任務完成的響應延遲增大了，因為每過一段時間才去輪詢一次read操作，而任務可能在兩次輪詢之間的任意時間完成，導致不能實時獲取數(shù)據(jù)，這也會導致整體數(shù)據(jù)吞吐量的降低。

四、IO multiplexing

IO multiplexing這個詞可能有點陌生，有些地方也稱這種IO方式為event driven IO。我們都知道，select/epoll的好處就在于單個process就可以同時處理多個網(wǎng)絡連接的IO。它的基本原理就是select/epoll這個function會不斷的輪詢所負責的所有socket，當某個socket有數(shù)據(jù)到達了，就通知用戶進程。它的流程如圖：

當用戶進程調用了select，那么整個進程會被block，而同時，kernel會“監(jiān)視”所有select負責的socket，當任何一個socket中的數(shù)據(jù)準備好了，select就會返回。這個時候用戶進程再調用read操作，將數(shù)據(jù)從kernel拷貝到用戶進程。

這個圖和blocking IO的圖其實并沒有太大的不同，事實上，還更差一些。因為這里需要使用兩個system call (select 和 recvfrom)，而blocking IO只調用了一個system call (recvfrom)。但是，用select的優(yōu)勢在于它可以同時處理多個connection。（多說一句。所以，如果處理的連接數(shù)不是很高的話，使用select/epoll的web server不一定比使用multi-threading + blocking IO的web server性能更好，可能延遲還更大。select/epoll的優(yōu)勢并不是對于單個連接能處理得更快，而是在于能處理更多的連接）

在IO multiplexing Model中，實際中，對于每一個socket，一般都設置成為non-blocking，但是，如上圖所示，整個用戶的process其實是一直被block的。只不過process是被select這個函數(shù)block，而不是被socket IO給block。

注意：

1.select函數(shù)返回結果中如果有文件可讀了，那么進程就可以通過調用accept()或recv()來讓kernel將位于內核中準備到的數(shù)據(jù)copy到用戶區(qū)。

2.select的優(yōu)勢在于可以處理多個連接，不適用于單個連接

import select, socket

sock = socket.socket()
sock.bind(('127.0.0.1', 8080))
sock.listen(5)

sock.setblocking(False)
listen_obj = [sock, ]

while True:
  r, w, e = select.select(listen_obj, [], [])

  for obj in r:
    if obj == sock:
      conn, addr = obj.accept()
      print('conn', conn)
      print('addr', addr)
      listen_obj.append(conn)
    else:
      data = obj.recv(1024)
      print(data.decode('utf8'))
      send_data = input('>>>')
      obj.send(send_data.encode('utf8'))

#############################client


import socket

sock = socket.socket()
sock.connect(('127.0.0.1', 8080))


while True:
  data = input('>>>')
  sock.send(data.encode('utf8'))
  recv_data = sock.recv(1024)
  print(recv_data.decode('utf8'))
sock.close()

以上實例，服務端kernel監(jiān)聽select負責的listen_obj中的所有socket對象。當任何一個socket對象激活，根據(jù)其類型判斷是否建立通信。

五、asynchronous I/O

linux下的asynchronous IO其實用得很少。先看一下它的流程：

用戶進程發(fā)起read操作之后，立刻就可以開始去做其它的事。而另一方面，從kernel的角度，當它收到一個asynchronous read之后，首先它會立刻返回，所以不會對用戶進程產生任何block。然后，kernel會等待數(shù)據(jù)準備完成，然后將數(shù)據(jù)拷貝到用戶內存，當這一切都完成之后，kernel會給用戶進程發(fā)送一個signal，告訴它read操作完成了。

很明顯，使用異步IO來編寫程序性能會遠遠高于同步IO，但是異步IO的缺點是編程模型復雜。

A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes;

An asynchronous I/O operation does not cause the requesting process to be blocked;

兩者的區(qū)別就在于synchronous IO做”IO operation”的時候會將process阻塞。按照這個定義，之前所述的blocking IO，non-blocking IO，IO multiplexing都屬于synchronous IO。有人可能會說，non-blocking IO并沒有被block啊。這里有個非常“狡猾”的地方，定義中所指的”IO operation”是指真實的IO操作，就是例子中的recvfrom這個system call。non-blocking IO在執(zhí)行recvfrom這個system call的時候，如果kernel的數(shù)據(jù)沒有準備好，這時候不會block進程。但是，當kernel中數(shù)據(jù)準備好的時候，recvfrom會將數(shù)據(jù)從kernel拷貝到用戶內存中，這個時候進程是被block了，在這段時間內，進程是被block的。而asynchronous IO則不一樣，當進程發(fā)起IO 操作之后，就直接返回再也不理睬了，直到kernel發(fā)送一個信號，告訴進程說IO完成。在這整個過程中，進程完全沒有被block。

各個IO Model的比較如圖所示：

經過上面的介紹，會發(fā)現(xiàn)non-blocking IO和asynchronous IO的區(qū)別還是很明顯的。在non-blocking IO中，雖然進程大部分時間都不會被block，但是它仍然要求進程去主動的check，并且當數(shù)據(jù)準備完成以后，也需要進程主動的再次調用recvfrom來將數(shù)據(jù)拷貝到用戶內存。而asynchronous IO則完全不同。它就像是用戶進程將整個IO操作交給了他人（kernel）完成，然后他人做完后發(fā)信號通知。在此期間，用戶進程不需要去檢查IO操作的狀態(tài)，也不需要主動的去拷貝數(shù)據(jù)。

以上這篇淺談Python基礎之I/O模型就是小編分享給大家的全部內容了，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論