從頭造輪子：python3 asyncio之 gather （3）

wilson排球發表於2022-01-17

前言

書接上文，本文造第三個輪子，也是asyncio包裡面非常常用的一個函式gather

一、知識準備

● 相對於前兩個函式，gather的使用頻率更高，因為它支援多個協程任務“同時”執行
● 理解__await__ __iter__的使用
● 理解關鍵字async/await，async/await是3.5之後的語法，和yield/yield from異曲同工
● 今天的文章有點長，請大家耐心看完

二、環境準備

元件	版本
python	3.7.7

三、run的實現

先來看下官方gather的使用方法：

|># more main.py
import asyncio

async def hello():
    print('enter hello ...')
    return 'return hello ...'

async def world():
    print('enter world ...')
    return 'return world ...'

async def helloworld():
    print('enter helloworld')
    ret = await asyncio.gather(hello(), world())
    print('exit helloworld')
    return ret

if __name__ == "__main__":
    ret = asyncio.run(helloworld())
    print(ret)
    
|># python3 main.py
enter helloworld
enter hello ...
enter world ...
exit helloworld
['return hello ...', 'return world ...']

來看下造的輪子的使用方式：

▶ more main.py
import wilsonasyncio

async def hello():
    print('enter hello ...')
    return 'return hello ...'

async def world():
    print('enter world ...')
    return 'return world ...'

async def helloworld():
    print('enter helloworld')
    ret = await wilsonasyncio.gather(hello(), world())
    print('exit helloworld')
    return ret


if __name__ == "__main__":
    ret = wilsonasyncio.run(helloworld())
    print(ret)

    
▶ python3 main.py
enter helloworld
enter hello ...
enter world ...
exit helloworld
['return hello ...', 'return world ...']

自己造的輪子也很好的執行了，下面我們來看下輪子的程式碼

四、程式碼解析

輪子程式碼

1）程式碼組成

|># tree
.
├── eventloops.py 
├── futures.py
├── main.py
├── tasks.py
├── wilsonasyncio.py

檔案	作用
eventloops.py	事件迴圈
futures.py	futures物件
tasks.py	tasks物件
wilsonasyncio.py	可呼叫方法集合
main.py	入口

2）程式碼概覽：

eventloops.py

類/函式	方法	物件	作用	描述
Eventloop			事件迴圈，一個執行緒只有執行一個
	`__init__`		初始化兩個重要物件 `self._ready` 與 `self._stopping`
		`self._ready`	所有的待執行任務都是從這個佇列取出來，非常重要
		`self._stopping`	事件迴圈完成的標誌
	`call_soon`		呼叫該方法會立即將任務新增到待執行佇列
	`run_once`		被`run_forever`呼叫，從`self._ready`佇列裡面取出任務執行
	`run_forever`		死迴圈，若`self._stopping`則退出迴圈
	`run_until_complete`		非常重要的函式，任務的起點和終點（後面詳細介紹）
	`create_task`		將傳入的函式封裝成`task`物件，這個操作會將`task.__step`新增到`__ready`佇列

`Handle`			所有的任務進入待執行佇列（`Eventloop.call_soon`）之前都會封裝成Handle物件
	`__init__`		初始化兩個重要物件 `self._callback` 與 `self._args`
		`self._callback`	待執行函式主體
		`self._args`	待執行函式引數
	`_run`		待執行函式執行

`get_event_loop`			獲取當前執行緒的事件迴圈

`_complete_eventloop`			將事件迴圈的`_stopping`標誌置位True

`run`			入口函式
`gather`			可以同時執行多個任務的入口函式	新增
`_GatheringFuture`			將每一個任務組成列表，封裝成一個新的類	新增

tasks.py

類/函式	方法	物件	作用	描述
Task			繼承自Future，主要用於整個協程執行的週期
	`__init__`		初始化物件 `self._coro` ，並且`call_soon`將`self.__step`加入`self._ready`佇列
		`self._coro`	使用者定義的函式主體
	`__step`		Task類的核心函式
	`__wakeup`		喚醒任務	新增

`ensure_future`			如果物件是一個Future物件，就返回，否則就會呼叫`create_task`返回，並且加入到`_ready`佇列

futures.py

類/函式	方法	物件	作用	描述
Future			主要負責與使用者函式進行互動
	`__init__`		初始化兩個重要物件 `self._loop` 與 `self._callbacks`
		`self._loop`	事件迴圈
		`self._callbacks`	回撥佇列，任務暫存佇列，等待時機成熟（狀態不是`PENDING`），就會進入`_ready`佇列
	`add_done_callback`		新增任務回撥函式，狀態`_PENDING`，就虎進入`_callbacks`佇列，否則進入`_ready`佇列
	`set_result`		獲取任務執行結果並儲存至`_result`，將狀態置位`_FINISH`，呼叫`__schedule_callbacks`
	`__schedule_callbacks`		將回撥函式放入`_ready`，等待執行
	`result`		獲取返回值
`__await__`			使用await就會進入這個方法	新增
`__iter__`			使用yield from就會進入這個方法	新增

3）執行過程

3.1）入口函式

main.py

    
if __name__ == "__main__":
    ret = wilsonasyncio.run(helloworld())
    print(ret)

ret = wilsonasyncio.run(helloworld())使用run，引數是使用者函式helloworld()，進入run，run的流程可以參考上一小節
run --> run_until_complete

3.2）事件迴圈啟動，同之前

3.3）第一次迴圈run_forever --> run_once

將_ready佇列的內容（即：task.__step）取出來執行，這裡的coro是helloworld()

    def __step(self, exc=None):
        coro = self._coro
        try:
            if exc is None:
                result = coro.send(None)
            else:
                result = coro.throw(exc)
        except StopIteration as exc:
            super().set_result(exc.value)
        else:
            blocking = getattr(result, '_asyncio_future_blocking', None)
            if blocking:
                result._asyncio_future_blocking = False
                result.add_done_callback(self.__wakeup, result)
        finally:
            self = None

__step較之前的程式碼有改動
result = coro.send(None)，進入使用者定義函式

async def helloworld():
    print('enter helloworld')
    ret = await wilsonasyncio.gather(hello(), world())
    print('exit helloworld')
    return ret

ret = await wilsonasyncio.gather(hello(), world())，這裡沒啥可說的，進入gather函式

def gather(*coros_or_futures, loop=None):
    loop = get_event_loop()

    def _done_callback(fut):
        nonlocal nfinished
        nfinished += 1

        if nfinished == nfuts:
            results = []
            for fut in children:
                res = fut.result()
                results.append(res)

            outer.set_result(results)

    children = []
    nfuts = 0
    nfinished = 0

    for arg in coros_or_futures:
        fut = tasks.ensure_future(arg, loop=loop)
        nfuts += 1
        fut.add_done_callback(_done_callback)

        children.append(fut)

    outer = _GatheringFuture(children, loop=loop)
    return outer

loop = get_event_loop()獲取事件迴圈
def _done_callback(fut)這個函式是回撥函式，細節後面分析，現在只需要知道任務（hello()與world()）執行完之後就會回撥就行
for arg in coros_or_futures for迴圈確保每一個任務都是Future物件，並且add_done_callback將回撥函式設定為_done_callback ，還有將他們加入到_ready佇列等待下一次迴圈排程
3個重要的變數：
children 裡面存放的是每一個非同步任務，在本例是hello()與world()
nfuts 存放是非同步任務的數量，在本例是2
nfinished 存放的是非同步任務完成的數量，目前是0，完成的時候是2
繼續往下，來到了_GatheringFuture ，看看原始碼：

class _GatheringFuture(Future):

    def __init__(self, children, *, loop=None):
        super().__init__(loop=loop)
        self._children = children

_GatheringFuture 最主要的作用就是將多個非同步任務放入self._children，然後用_GatheringFuture 這個物件來管理。需要注意，這個物件繼承了Future
至此，gather完成初始化，返回了outer，其實就是_GatheringFuture
總結一下gather，初始化了3個重要的變數，後面用來存放狀態；給每一個非同步任務新增回撥函式；將多個非同步子任務合併，並且使用一個Future物件去管理

3.3.1）gather完成，回到helloworld()

async def helloworld():
    print('enter helloworld')
    ret = await wilsonasyncio.gather(hello(), world())
    print('exit helloworld')
    return ret

ret = await wilsonasyncio.gather(hello(), world()) gather返回_GatheringFuture ，隨後使用await，就會進入Future.__await__

    def __await__(self):
        if self._state == _PENDING:
            self._asyncio_future_blocking = True
            yield self
        return self.result()

由於_GatheringFuture 的狀態是_PENDING，所以進入if，遇到yield self，將self，也就是_GatheringFuture 返回（這裡注意yield的用法，流程控制的功能）
那yield回到哪兒去了呢？從哪兒send就回到哪兒去，所以，他又回到了task.__step函式裡面去

    def __step(self, exc=None):
        coro = self._coro
        try:
            if exc is None:
                result = coro.send(None)
            else:
                result = coro.throw(exc)
        except StopIteration as exc:
            super().set_result(exc.value)
        else:
            blocking = getattr(result, '_asyncio_future_blocking', None)
            if blocking:
                result._asyncio_future_blocking = False
                result.add_done_callback(self.__wakeup, result)
        finally:
            self = None

這裡是本函式的第一個核心點，流程控制/跳轉，需要非常的清晰，如果搞不清楚的同學，再詳細的去閱讀有關yield/yield from的文章
繼續往下走，由於使用者函式helloworld()沒有結束，所以不會拋異常，所以來到了else分支
blocking = getattr(result, '_asyncio_future_blocking', None)這裡有一個重要的狀態，那就是_asyncio_future_blocking ，只有呼叫__await__，才會有這個引數，預設是true，這個引數主要的作用：一個非同步函式，如果呼叫了多個子非同步函式，那證明該非同步函式沒有結束（後面詳細講解），就需要新增“喚醒”回撥
result._asyncio_future_blocking = False將引數置位False，並且新增self.__wakeup回撥等待喚醒
__step函式完成

這裡需要詳細講解一下_asyncio_future_blocking 的作用

如果在非同步函式裡面出現了await，呼叫其他非同步函式的情況，就會走到Future.__await__將_asyncio_future_blocking 設定為true

async def helloworld():
    print('enter helloworld')
    ret = await wilsonasyncio.gather(hello(), world())
    print('exit helloworld')
    return ret
    
class Future:
    def __await__(self):
        if self._state == _PENDING:
            self._asyncio_future_blocking = True
            yield self
        return self.result()

這樣做了之後，在task.__step中就會把該任務的回撥函式設定為__wakeup
為啥要__wakeup，因為helloworld()並沒有執行完成，所以需要再次__wakeup來喚醒helloworld()

這裡揭示了，在Eventloop裡面，只要使用await呼叫其他非同步任務，就會掛起父任務，轉而去執行子任務，直至子任務完成之後，回到父任務繼續執行

先喝口水，休息一下，下面更復雜。。。

3.4）第二次迴圈run_forever --> run_once

eventloops.py

    def run_once(self):
        ntodo = len(self._ready)
        for _ in range(ntodo):
            handle = self._ready.popleft()
            handle._run()

從佇列中取出資料，此時_ready佇列有兩個任務，hello() world()，在gather的for迴圈時新增的

async def hello():
    print('enter hello ...')
    return 'return hello ...'

async def world():
    print('enter world ...')
    return 'return world ...'

由於hello() world()沒有await呼叫其他非同步任務，所以他們的執行比較簡單，分別一次task.__step就結束了，到達set_result()處
set_result()將回撥函式放入_ready佇列，等待下次迴圈執行

3.5）第三次迴圈run_forever --> run_once

我們來看下回撥函式

    def _done_callback(fut):
        nonlocal nfinished
        nfinished += 1

        if nfinished == nfuts:
            results = []
            for fut in children:
                res = fut.result()
                results.append(res)

            outer.set_result(results)

沒錯，這是本文的第二個核心點，我們來仔細分析一下
這段程式碼最主要的邏輯，其實就是，只有當所有的子任務執行完之後，才會啟動父任務的回撥函式，本文中只有hello() world()都執行完之後if nfinished == nfuts: ，才會啟動父任務_GatheringFuture的回撥outer.set_result(results)
results.append(res)將子任務的結果取出來，放進父任務的results裡面
子任務執行完成，終於到了喚醒父任務的時候了task.__wakeup

    def __wakeup(self, future):
        try:
            future.result()
        except Exception as exc:
            raise exc
        else:
            self.__step()
        self = None

3.6）第四次迴圈run_forever --> run_once

future.result()從_GatheringFuture取出結果，然後進入task.__step

    def __step(self, exc=None):
        coro = self._coro
        try:
            if exc is None:
                result = coro.send(None)
            else:
                result = coro.throw(exc)
        except StopIteration as exc:
            super().set_result(exc.value)
        else:
            blocking = getattr(result, '_asyncio_future_blocking', None)
            if blocking:
                result._asyncio_future_blocking = False
                result.add_done_callback(self.__wakeup, result)
        finally:
            self = None

result = coro.send(None)其實就是helloworld() --> send又要跳回到當初yield的地方，那就是Future.__await__

    def __await__(self):
        if self._state == _PENDING:
            self._asyncio_future_blocking = True
            yield self
        return self.result()

return self.result()終於返回到helloworld()函式裡面去了

async def helloworld():
    print('enter helloworld')
    ret = await wilsonasyncio.gather(hello(), world())
    print('exit helloworld')
    return ret

helloworld終於也執行完了，返回了ret

3.7）第五次迴圈run_forever --> run_once

迴圈結束
回到run

3.8）回到主函式，獲取返回值

if __name__ == "__main__":
    ret = wilsonasyncio.run(helloworld())
    print(ret)

3.9）執行結果

▶ python3 main.py
enter helloworld
enter hello ...
enter world ...
exit helloworld
['return hello ...', 'return world ...']

五、流程總結

六、小結

● 終於結束了，這是一個非常長的小節了，但是我感覺很多細節還是沒有說到，大家有問題請及時留言探討
● _GatheringFuture一個非常重要的物件，它不但追蹤了hello() world()的執行狀態，喚醒helloworld()，並且將返回值傳遞給helloworld
● await async yield對流程的控制需要特別關注
● 本文中的程式碼，參考了python 3.7.7中asyncio的原始碼，裁剪而來
● 本文中程式碼：程式碼

至此，本文結束
在下才疏學淺，有撒湯漏水的，請各位不吝賜教...
更多文章，請關注我：wilson.chai

從頭造輪子：python3 asyncio 之 run（2）
2021-12-28
Python
從頭造輪子：python3 asyncio之 sleep （4）
2022-03-10
Python
Swift 造輪子之自制 HUD
2017-12-19
Swift
造輪子之圖片輪播元件(swiper)
2019-01-03
元件
造輪子之自定義授權策略
2023-10-09
造輪子-ThreadPoolExecutor
2021-03-05
thread
造輪子之圖片預覽元件(preview)
2019-01-08
元件View
那些年我造的輪子之RPC
2018-04-05
RPC
python3 使用 asyncio 代替執行緒
2019-02-16
Python執行緒
造一個「輪子」musionUI
2019-02-28
UI
造輪子之單層應用總結篇
2023-10-26
asyncio的基本使用框架，python高效處理資料，asyncio.gather(),asyncio. create_task(),asyncio.run(main())
2023-04-26
框架PythonAI
造了個滾輪控制元件輪子
2019-02-27
控制元件
書童造輪子之自動生成資料字典
2017-04-01
造輪子-strace（二）實現
2022-01-05
造輪子之多語言管理
2023-10-11
給 Java 造個輪子 - Chain
2021-12-04
JavaAI
Go~避免重複造輪子
2024-03-18
Go
前端工程-從原理到輪子之JS模組化
2017-09-21
前端JS
原生js造輪子之模仿JQ的slideDown()與slideUp()
2018-11-19
JSIDE
在NPM釋出自己造的輪子
2020-07-29
NPM
smol 作者造新輪子 futures-lite
2020-06-24
「造個輪子」——cicada 原始碼分析
2019-02-28
原始碼
原生JavaScript實現造日曆輪子
2019-05-07
JavaScript
造後臺輪子引發的思考
2020-10-28
精讀《怎麼用 React Hooks 造輪子》
2018-11-19
ReactHook
一起學習造輪子（二）：從零開始寫一個Redux
2018-06-21
Redux
造個輪子之基於 Netty 實現自己的 RPC 框架
2019-03-04
NettyRPC框架
輕鬆開發React元件和造輪子指北
2019-03-04
React元件
「造個輪子」——cicada(輕量級 WEB 框架)
2019-01-19
Web框架
一年前端造的輪子是什麼樣子？
2019-04-12
前端
一起學習造輪子（三）：從零開始寫一個React-Redux
2018-07-03
ReactRedux
突破tls/ja3新輪子
2023-05-02
TLS
造輪子：minicap/minitouch 二次開發
2020-03-15
[ 造輪子 ] 手動封裝 AJAX （三） —— 最終版
2018-12-30
封裝
[ 造輪子 ] 手動封裝 AJAX （一） —— 基礎版
2018-12-26
封裝
【小程式】實現複用及造輪子入門
2018-08-03
為什麼Java有了synchronized之後還造了Lock鎖這個輪子？
2022-05-26
Javasynchronized

從頭造輪子：python3 asyncio之 gather （3）

前言

一、知識準備

二、環境準備

三、`run`的實現

四、程式碼解析

五、流程總結

六、小結

相關文章

從頭造輪子：python3 asyncio之 gather （3）

前言

一、知識準備

二、環境準備

三、run的實現

四、程式碼解析

五、流程總結

六、小結

相關文章

三、`run`的實現