本文主要討論下面幾個問題：
- 什麼是非同步（Asynchronous）程式設計？
- 為什麼要使用非同步程式設計？
- 在 Python 中有哪些實現非同步程式設計的方法？
- Python 3.5 如何使用
async/await實現非同步網路爬蟲？
所謂非同步是相對於同步（Synchronous）的概念來說的，之所以容易造成混亂，是因為剛開始接觸這兩個概念時容易把同步看做是同時，而同時不是意味著並行（Parallel）嗎？然而實際上同步或者非同步是針對於時間軸的概念，同步意味著順序、統一的時間軸，而非同步則意味著亂序、效率優先的時間軸。比如在爬蟲執行時，先抓取 A 頁面，然後從中提取下一層頁面 B 的連結，此時的爬蟲程式的執行只能是同步的，B 頁面只能等到 A 頁面處理完成之後才能抓取；然而對於獨立的兩個頁面 A1 和 A2，在處理 A1 網路請求的時間裡，與其讓 CPU 空閒而 A2 等在後面，不如先處理 A2，等到誰先完成網路請求誰就先來進行處理，這樣可以更加充分地利用 CPU，但是 A1 和 A2 的執行順序則是不確定的，也就是非同步的。
很顯然，在某些情況下采用非同步程式設計可以提高程式執行效率，減少不必要的等待時間，而之所以能夠做到這一點，是因為計算機的 CPU 與其它裝置是獨立運作的，同時 CPU 的執行效率遠高於其他裝置的讀寫（I/O）效率。為了利用非同步程式設計的優勢，人們想出了很多方法來重新安排、排程（Schedule）程式的執行順序，從而最大化 CPU 的使用率，其中包括程式、執行緒、協程等（具體可參考《Python 中的程式、執行緒、協程、同步、非同步、回撥》）。在 Python 3.5 以前通過 @types.coroutine 作為修飾器的方式將一個生成器（Generator）轉化為一個協程，而在 Python 3.5 中則通過關鍵詞 async/await 來定義一個協程，同時也將 asyncio 納入為標準庫，用於實現基於協程的非同步程式設計。
要使用 asyncio 需要理解下面幾個概念：
- Event loop
- Coroutine
- Future & Task
Event loop
瞭解 JavaScript 或 Node.js 肯定對事件迴圈不陌生，我們可以把它看作是一種迴圈式（loop）的排程機制，它可以安排需要 CPU 執行的操作優先執行，而會被 I/O 阻塞的行為則進入等待佇列：
asyncio 自帶了事件迴圈：
|
1 2 3 4 5 |
import asyncio loop = anscio.get_event_loop() # loop.run_until_complete(coro()) loop.close() |
當然你也可以選擇其它的實現形式，例如 Sanic 框架採用的 uvloop，用起來也非常簡單（ 至於效能上是否更優我沒有驗證過，但至少在 Jupyter Notebook 上 uvloop 用起來更方便）：
|
1 2 3 4 5 |
import asyncio import uvloop loop = uvloop.new_event_loop() asyncio.set_event_loop(loop) |
Coroutine
Python 3.5 以後推薦使用 async/await 關鍵詞來定義協程，它具有如下特性：
- 通過
await將可能阻塞的行為掛起，直到有結果之後繼續執行，Event loop 也是據此來對多個協程的執行進行排程的； - 協程並不像一般的函式一樣，通過
coro()進行呼叫並不會執行它，而只有將它放入 Event loop 進行排程才能執行。
一個簡單的例子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
import uvloop import asyncio loop = uvloop.new_event_loop() asyncio.set_event_loop(loop) async def compute(a, b): print("Computing {} + {}...".format(a, b)) await asyncio.sleep(a+b) return a + b tasks = [] for i, j in zip(range(3), range(3)): print(i, j) tasks.append(compute(i, j)) loop.run_until_complete(asyncio.gather(*tasks)) loop.close() ### OUTPUT """ 0 0 1 1 2 2 Computing 0 + 0... Computing 1 + 1... Computing 2 + 2... CPU times: user 1.05 ms, sys: 1.21 ms, total: 2.26 ms Wall time: 4 s """ |
由於我們沒辦法知道協程將在什麼時候呼叫及返回，asyncio 中提供了 Future 這一物件來追蹤它的執行結果。
Future & Task
Future 相當於 JavaScript 中的 Promise，用於儲存未來可能返回的結果。而 Task 則是 Future 的子類，與 Future 不同的是它包含了一個將要執行的協程（ 從而組成一個需要被排程的任務）。還以上面的程式為例，如果想要知道計算結果，可以通過 asyncio.ensure_future() 方法將協程包裹成 Task，最後再來讀取結果：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
import uvloop import asyncio loop = uvloop.new_event_loop() asyncio.set_event_loop(loop) async def compute(a, b): print("Computing {} + {}...".format(a, b)) await asyncio.sleep(a+b) return a + b tasks = [] for i, j in zip(range(3), range(3)): print(i, j) tasks.append(asyncio.ensure_future(compute(i, j))) loop.run_until_complete(asyncio.gather(*tasks)) for t in tasks: print(t.result()) loop.close() ### OUTPUT """ 0 0 1 1 2 2 Computing 0 + 0... Computing 1 + 1... Computing 2 + 2... 0 2 4 CPU times: user 1.62 ms, sys: 1.86 ms, total: 3.49 ms Wall time: 4.01 s """ |
非同步網路請求
Python 處理網路請求最好用的庫就是 requests（應該沒有之一），但由於它的請求過程是同步阻塞的，因此只好選用 aiohttp。為了對比同步與非同步情況下的差異，先偽造一個假的非同步處理伺服器：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sanic import Sanic from sanic.response import text import asyncio app = Sanic(__name__) @app.route("/") @app.route("/") async def index(req, word=""): t = len(word) / 10 await asyncio.sleep(t) return text("It costs {}s to process `{}`!".format(t, word)) app.run() |
伺服器處理耗時與請求引數（word）長度成正比，採用同步請求方式，執行結果如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import requests as req URL = "http://127.0.0.1:8000/{}" words = ["Hello", "Python", "Fans", "!"] for word in words: resp = req.get(URL.format(word)) print(resp.text) ### OUTPUT """ It costs 0.5s to process `Hello`! It costs 0.6s to process `Python`! It costs 0.4s to process `Fans`! It costs 0.1s to process `!`! CPU times: user 18.5 ms, sys: 2.98 ms, total: 21.4 ms Wall time: 1.64 s """ |
採用非同步請求，執行結果如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
import asyncio import aiohttp import uvloop URL = "http://127.0.0.1:8000/{}" words = ["Hello", "Python", "Fans", "!"] async def getPage(session, word): with aiohttp.Timeout(10): async with session.get(URL.format(word)) as resp: print(await resp.text()) loop = uvloop.new_event_loop() asyncio.set_event_loop(loop) session = aiohttp.ClientSession(loop=loop) tasks = [] for word in words: tasks.append(getPage(session, word)) loop.run_until_complete(asyncio.gather(*tasks)) loop.close() session.close() ### OUTPUT """ It costs 0.1s to process `!`! It costs 0.4s to process `Fans`! It costs 0.5s to process `Hello`! It costs 0.6s to process `Python`! CPU times: user 61.2 ms, sys: 18.2 ms, total: 79.3 ms Wall time: 732 ms """ |
從執行時間上來看效果是很明顯的。
### 未完待續
接下來將對 aiohttp 進行簡單封裝，更有利於偽裝成普通瀏覽器使用者訪問，從而服務於爬蟲傳送網路請求。
參考
– END –
打賞支援我寫出更多好文章，謝謝！
打賞作者
打賞支援我寫出更多好文章，謝謝！
