在IO編程一節中，我們已經知道，CPU的速度遠遠快于磁盤、網絡等IO。在一個線程中，CPU執行代碼的速度極快，然而，一旦遇到IO操作，如讀寫文件、發送網絡數據時，就需要等待IO操作完成，才能繼續進行下一步操作。這種情況稱為同步IO。
在IO操作的過程中，當前線程被掛起，而其他需要CPU執行的代碼就無法被當前線程執行了。
因為一個IO操作就阻塞了當前線程，導致其他代碼無法執行，所以我們必須使用多線程或者多進程來并發執行代碼，為多個用戶服務。每個用戶都會分配一個線程，如果遇到IO導致線程被掛起，其他用戶的線程不受影響。
多線程和多進程的模型雖然解決了并發問題，但是系統不能無上限地增加線程。由于系統切換線程的開銷也很大，所以，一旦線程數量過多，CPU的時間就花在線程切換上了，真正運行代碼的時間就少了，結果導致性能嚴重下降。
由于我們要解決的問題是CPU高速執行能力和IO設備的龜速嚴重不匹配，多線程和多進程只是解決這一問題的一種方法。
另一種解決IO問題的方法是異步IO。當代碼需要執行一個耗時的IO操作時，它只發出IO指令，并不等待IO結果，然后就去執行其他代碼了。一段時間后，當IO返回結果時，再通知CPU進行處理。
可以想象如果按普通順序寫出的代碼實際上是沒法完成異步IO的：
do_some_code()f = open('/path/to/file', 'r')r = f.read() # <== 線程停在此處等待IO操作結果# IO操作完成后線程才能繼續執行:do_some_code(r)所以，同步IO模型的代碼是無法實現異步IO模型的。
異步IO模型需要一個消息循環，在消息循環中，主線程不斷地重復“讀取消息-處理消息”這一過程：
loop = get_event_loop()while True: event = loop.get_event() PRocess_event(event)消息模型其實早在應用在桌面應用程序中了。一個GUI程序的主線程就負責不停地讀取消息并處理消息。所有的鍵盤、鼠標等消息都被發送到GUI程序的消息隊列中，然后由GUI程序的主線程處理。
由于GUI線程處理鍵盤、鼠標等消息的速度非常快，所以用戶感覺不到延遲。某些時候，GUI線程在一個消息處理的過程中遇到問題導致一次消息處理時間過長，此時，用戶會感覺到整個GUI程序停止響應了，敲鍵盤、點鼠標都沒有反應。這種情況說明在消息模型中，處理一個消息必須非常迅速，否則，主線程將無法及時處理消息隊列中的其他消息，導致程序看上去停止響應。
消息模型是如何解決同步IO必須等待IO操作這一問題的呢？當遇到IO操作時，代碼只負責發出IO請求，不等待IO結果，然后直接結束本輪消息處理，進入下一輪消息處理過程。當IO操作完成后，將收到一條“IO完成”的消息，處理該消息時就可以直接獲取IO操作結果。
在“發出IO請求”到收到“IO完成”的這段時間里，同步IO模型下，主線程只能掛起，但異步IO模型下，主線程并沒有休息，而是在消息循環中繼續處理其他消息。這樣，在異步IO模型下，一個線程就可以同時處理多個IO請求，并且沒有切換線程的操作。對于大多數IO密集型的應用程序，使用異步IO將大大提升系統的多任務處理能力。
一、協程
在學習異步IO模型前，我們先來了解協程。
協程，又稱微線程，纖程。英文名Coroutine。
協程的概念很早就提出來了，但直到最近幾年才在某些語言（如Lua）中得到廣泛應用。
子程序，或者稱為函數，在所有語言中都是層級調用，比如A調用B，B在執行過程中又調用了C，C執行完畢返回，B執行完畢返回，最后是A執行完畢。
所以子程序調用是通過棧實現的，一個線程就是執行一個子程序。
子程序調用總是一個入口，一次返回，調用順序是明確的。而協程的調用和子程序不同。
協程看上去也是子程序，但執行過程中，在子程序內部可中斷，然后轉而執行別的子程序，在適當的時候再返回來接著執行。
注意，在一個子程序中中斷，去執行其他子程序，不是函數調用，有點類似CPU的中斷。比如子程序A、B：
def A(): print('1') print('2') print('3')def B(): print('x') print('y') print('z')假設由協程執行，在執行A的過程中，可以隨時中斷，去執行B，B也可能在執行過程中中斷再去執行A，結果可能是：
12xy3z但是在A中是沒有調用B的，所以協程的調用比函數調用理解起來要難一些。
看起來A、B的執行有點像多線程，但協程的特點在于是一個線程執行，那和多線程比，協程有何優勢？
最大的優勢就是協程極高的執行效率。因為子程序切換不是線程切換，而是由程序自身控制，因此，沒有線程切換的開銷，和多線程比，線程數量越多，協程的性能優勢就越明顯。
第二大優勢就是不需要多線程的鎖機制，因為只有一個線程，也不存在同時寫變量沖突，在協程中控制共享資源不加鎖，只需要判斷狀態就好了，所以執行效率比多線程高很多。
因為協程是一個線程執行，那怎么利用多核CPU呢？最簡單的方法是多進程+協程，既充分利用多核，又充分發揮協程的高效率，可獲得極高的性能。
Python對協程的支持是通過generator實現的。
在generator中，我們不但可以通過for循環來迭代，還可以不斷調用next()函數獲取由yield語句返回的下一個值。
但是Python的yield不但可以返回一個值，它還可以接收調用者發出的參數。
來看例子：
傳統的生產者-消費者模型是一個線程寫消息，一個線程取消息，通過鎖機制控制隊列和等待，但一不小心就可能死鎖。
如果改用協程，生產者生產消息后，直接通過yield跳轉到消費者開始執行，待消費者執行完畢后，切換回生產者繼續生產，效率極高：
def consumer(): r = '' while True: n = yield r if not n: return print('[CONSUMER] Consuming %s...' % n) r = '200 OK'def produce(c): c.send(None) n = 0 while n < 5: n = n + 1 print('[PRODUCER] Producing %s...' % n) r = c.send(n) print('[PRODUCER] Consumer return: %s' % r) c.close()c = consumer()produce(c)執行結果：
[PRODUCER] Producing 1...[CONSUMER] Consuming 1...[PRODUCER] Consumer return: 200 OK[PRODUCER] Producing 2...[CONSUMER] Consuming 2...[PRODUCER] Consumer return: 200 OK[PRODUCER] Producing 3...[CONSUMER] Consuming 3...[PRODUCER] Consumer return: 200 OK[PRODUCER] Producing 4...[CONSUMER] Consuming 4...[PRODUCER] Consumer return: 200 OK[PRODUCER] Producing 5...[CONSUMER] Consuming 5...[PRODUCER] Consumer return: 200 OK注意到consumer函數是一個generator，把一個consumer傳入produce后：
首先調用c.send(None)啟動生成器；
然后，一旦生產了東西，通過c.send(n)切換到consumer執行；
consumer通過yield拿到消息，處理，又通過yield把結果傳回；
produce拿到consumer處理的結果，繼續生產下一條消息；
produce決定不生產了，通過c.close()關閉consumer，整個過程結束。
整個流程無鎖，由一個線程執行，produce和consumer協作完成任務，所以稱為“協程”，而非線程的搶占式多任務。
最后套用Donald Knuth的一句話總結協程的特點：
“子程序就是協程的一種特例?！?/p>
二、asyncio
asyncio是Python 3.4版本引入的標準庫，直接內置了對異步IO的支持。
asyncio的編程模型就是一個消息循環。我們從asyncio模塊中直接獲取一個EventLoop的引用，然后把需要執行的協程扔到EventLoop中執行，就實現了異步IO。
用asyncio實現Hello world代碼如下：
import asyncio@asyncio.coroutinedef hello(): print("Hello world!") # 異步調用asyncio.sleep(1): r = yield from asyncio.sleep(1) print("Hello again!")# 獲取EventLoop:loop = asyncio.get_event_loop()# 執行coroutineloop.run_until_complete(hello())loop.close()@asyncio.coroutine把一個generator標記為coroutine類型，然后，我們就把這個coroutine扔到EventLoop中執行。
hello()會首先打印出Hello world!，然后，yield from語法可以讓我們方便地調用另一個generator。由于asyncio.sleep()也是一個coroutine，所以線程不會等待asyncio.sleep()，而是直接中斷并執行下一個消息循環。當asyncio.sleep()返回時，線程就可以從yield from拿到返回值（此處是None），然后接著執行下一行語句。
把asyncio.sleep(1)看成是一個耗時1秒的IO操作，在此期間，主線程并未等待，而是去執行EventLoop中其他可以執行的coroutine了，因此可以實現并發執行。
我們用Task封裝兩個coroutine試試：
import threadingimport asyncio@asyncio.coroutinedef hello(): print('Hello world! (%s)' % threading.currentThread()) yield from asyncio.sleep(1) print('Hello again! (%s)' % threading.currentThread())loop = asyncio.get_event_loop()tasks = [hello(), hello()]loop.run_until_complete(asyncio.wait(tasks))loop.close()觀察執行過程：
Hello world! (<_MainThread(MainThread, started 140735195337472)>)Hello world! (<_MainThread(MainThread, started 140735195337472)>)(暫停約1秒)Hello again! (<_MainThread(MainThread, started 140735195337472)>)Hello again! (<_MainThread(MainThread, started 140735195337472)>)由打印的當前線程名稱可以看出，兩個coroutine是由同一個線程并發執行的。
如果把asyncio.sleep()換成真正的IO操作，則多個coroutine就可以由一個線程并發執行。
我們用asyncio的異步網絡連接來獲取sina、sohu和163的網站首頁：
import asyncio@asyncio.coroutinedef wget(host): print('wget %s...' % host) connect = asyncio.open_connection(host, 80) reader, writer = yield from connect header = 'GET / HTTP/1.0/r/nHost: %s/r/n/r/n' % host writer.write(header.encode('utf-8')) yield from writer.drain() while True: line = yield from reader.readline() if line == b'/r/n': break print('%s header > %s' % (host, line.decode('utf-8').rstrip())) # Ignore the body, close the socket writer.close()loop = asyncio.get_event_loop()tasks = [wget(host) for host in ['www.sina.com.cn', 'www.sohu.com', 'www.163.com']]loop.run_until_complete(asyncio.wait(tasks))loop.close()執行結果如下：
wget www.sohu.com...wget www.sina.com.cn...wget www.163.com...(等待一段時間)(打印出sohu的header)www.sohu.com header > HTTP/1.1 200 OKwww.sohu.com header > Content-Type: text/html...(打印出sina的header)www.sina.com.cn header > HTTP/1.1 200 OKwww.sina.com.cn header > Date: Wed, 20 May 2015 04:56:33 GMT...(打印出163的header)www.163.com header > HTTP/1.0 302 Moved Temporarilywww.163.com header > Server: Cdn Cache Server V2.0...可見3個連接由一個線程通過coroutine并發完成。
小結
asyncio提供了完善的異步IO支持；
異步操作需要在coroutine中通過yield from完成；
多個coroutine可以封裝成一組Task然后并發執行。
三、async/await
用asyncio提供的@asyncio.coroutine可以把一個generator標記為coroutine類型，然后在coroutine內部用yield from調用另一個coroutine實現異步操作。
為了簡化并更好地標識異步IO，從Python 3.5開始引入了新的語法async和await，可以讓coroutine的代碼更簡潔易讀。
請注意，async和await是針對coroutine的新語法，要使用新的語法，只需要做兩步簡單的替換：
把@asyncio.coroutine替換為async；把yield from替換為await。讓我們對比一下上一節的代碼：
@asyncio.coroutinedef hello(): print("Hello world!") r = yield from asyncio.sleep(1) print("Hello again!")用新語法重新編寫如下：
async def hello(): print("Hello world!") r = await asyncio.sleep(1) print("Hello again!")剩下的代碼保持不變。
小結
Python從3.5版本開始為asyncio提供了async和await的新語法；
注意新語法只能用在Python 3.5以及后續版本，如果使用3.4版本，則仍需使用上一節的方案。
四、aiohttp
asyncio可以實現單線程并發IO操作。如果僅用在客戶端，發揮的威力不大。如果把asyncio用在服務器端，例如Web服務器，由于HTTP連接就是IO操作，因此可以用單線程+coroutine實現多用戶的高并發支持。
asyncio實現了TCP、UDP、SSL等協議，aiohttp則是基于asyncio實現的HTTP框架。
我們先安裝aiohttp：
pip install aiohttp然后編寫一個HTTP服務器，分別處理以下URL：
/ - 首頁返回b'<h1>Index</h1>'；
/hello/{name} - 根據URL參數返回文本hello, %s!。
代碼如下：
import asynciofrom aiohttp import webasync def index(request): await asyncio.sleep(0.5) return web.Response(body=b'<h1>Index</h1>')async def hello(request): await asyncio.sleep(0.5) text = '<h1>hello, %s!</h1>' % request.match_info['name'] return web.Response(body=text.encode('utf-8'))async def init(loop): app = web.application(loop=loop) app.router.add_route('GET', '/', index) app.router.add_route('GET', '/hello/{name}', hello) srv = await loop.create_server(app.make_handler(), '127.0.0.1', 8000) print('Server started at http://127.0.0.1:8000...') return srvloop = asyncio.get_event_loop()loop.run_until_complete(init(loop))loop.run_forever()注意aiohttp的初始化函數init()也是一個coroutine，loop.create_server()則利用asyncio創建TCP服務。
新聞熱點
疑難解答
