python——asyncio模塊實現協程、異步編程

時間  2019-11-20
標籤 python asyncio 模塊 實現 異步 編程 欄目 Python 简体版
原文   原文鏈接

咱們都知道，如今的服務器開發對於IO調度的優先級控制權已經再也不依靠系統，都但願採用協程的方式實現高效的併發任務，如js、lua等在異步協程方面都作的很強大。python

Python在3.4版本也加入了協程的概念，並在3.5肯定了基本完善的語法和實現方式。同時3.6也對其進行了如解除了await和yield在同一個函數體限制等相關的優化。程序員

event_loop 事件循環：程序開啓一個無限的循環，程序員會把一些函數註冊到事件循環上。當知足事件發生的時候，調用相應的協程函數。
coroutine 協程：協程對象，指一個使用async關鍵字定義的函數，它的調用不會當即執行函數，而是會返回一個協程對象。協程對象須要註冊到事件循環，由事件循環調用。
task 任務：一個協程對象就是一個原生能夠掛起的函數，任務則是對協程進一步封裝，其中包含任務的各類狀態。
future： 表明未來執行或沒有執行的任務的結果。它和task上沒有本質的區別
async/await 關鍵字：python3.5 用於定義協程的關鍵字，async定義一個協程，await用於掛起阻塞的異步調用接口。服務器

 

【一】建立協程網絡

首先定義一個協程，在def前加入async聲明，就能夠定義一個協程函數。多線程

一個協程函數不能直接調用運行，只能把協程加入到事件循環loop中。asyncio.get_event_loop方法能夠建立一個事件循環，而後使用run_until_complete將協程註冊到事件循環，並啓動事件循環。併發

例如：app

 

[python]  view plain  copy
 
  1. import asyncio  
  2.    
  3. async def fun():  
  4.     print('hello word')  
  5.    
  6. loop = asyncio.get_event_loop()  
  7.   
  8. loop.run_until_complete(fun())  

 

 

 

【二】任務對象task異步

協程對象不能直接運行，在註冊事件循環的時候，實際上是run_until_complete方法將協程包裝成爲了一個任務（task）對象。所謂task對象是Future類的子類。保存了協程運行後的狀態，用於將來獲取協程的結果。async

例如：函數

 

[python]  view plain  copy
 
  1. import asyncio  
  2.    
  3. async def fun():  
  4.     print('hello word')  
  5.     return 'miao'  
  6.    
  7. loop = asyncio.get_event_loop()  
  8. task = loop.create_task(fun())  
  9. print(task)  
  10. loop.run_until_complete(task)  
  11. print(task)  


 

建立task後，task在加入事件循環以前是pending狀態，由於do_some_work中沒有耗時的阻塞操做，task很快就執行完畢了。後面打印的finished狀態。
asyncio.ensure_future 和 loop.create_task均可以建立一個task，run_until_complete的參數是一個futrue對象。當傳入一個協程，其內部會自動封裝成task，task是Future的子類。isinstance(task, asyncio.Future)將會輸出True。

 



【三】綁定回調

在task執行完畢的時候能夠獲取執行的結果，回調的最後一個參數是future對象，經過該對象能夠獲取協程返回值。若是回調須要多個參數，能夠經過偏函數導入。

例如：

 

[python]  view plain  copy
 
  1. import asyncio  
  2.    
  3. async def fun():  
  4.     print('hello word')  
  5.     return 'miao'  
  6.    
  7.   
  8. def callback(future):  
  9.     print('Callback: ', future.result())  
  10.    
  11. loop = asyncio.get_event_loop()  
  12. task = loop.create_task(fun())  
  13. #print(task)  
  14. task.add_done_callback(callback)  
  15. loop.run_until_complete(task)  
  16. #print(task)  


 

 

也可使用ensure_future獲取返回值

例如：

 

[python]  view plain  copy
 
  1. import asyncio  
  2.    
  3. async def fun():  
  4.     print('hello word')  
  5.     return 'miao'  
  6.    
  7.   
  8. #def callback(future):  
  9.     #print('Callback: ', future.result())  
  10.    
  11. loop = asyncio.get_event_loop()  
  12. #task = loop.create_task(fun())  
  13. #task.add_done_callback(callback)  
  14. task = asyncio.ensure_future(fun())  
  15. loop.run_until_complete(task)  
  16.   
  17. print('the fun() return is: {}'.format(task.result()))  
  18.   
  19.    



 

 

【四】await阻塞

使用async能夠定義協程對象，使用await能夠針對耗時的操做進行掛起，就像生成器裏的yield同樣，函數讓出控制權。協程遇到await，事件循環將會掛起該協程，執行別的協程，直到其餘的協程也掛起或者執行完畢，再進行下一個協程的執行。
耗時的操做通常是一些IO操做，例如網絡請求，文件讀取等。咱們使用asyncio.sleep函數來模擬IO操做。協程的目的也是讓這些IO操做異步化。

例如：

 

[python]  view plain  copy
 
  1. #coding:utf-8    
  2. import asyncio  
  3. import threading    
  4. import time   
  5. async def hello():  
  6.     print("hello 1")  
  7.     r = await asyncio.sleep(1)  
  8.     print("hello 2")  
  9.     
  10.   
  11. def main():  
  12.     loop = asyncio.get_event_loop()  
  13.   
  14.     print("begin")  
  15.     loop.run_until_complete(hello())   
  16.     loop.close()  
  17.     print("end")  
  18.   
  19.   
  20. if __name__ == "__main__":  
  21.     main()  


 

 

【五】3.6更新

①能夠在同一個協程函數中同時使用await和yield

例如：

[python]  view plain  copy
 
  1. import asyncio  
  2. async def ticker(delay, to):  
  3.     for i in range(to):  
  4.         yield i  
  5.         await asyncio.sleep(delay)  
  6.   
  7.   
  8. async def run():  
  9.     async for i in ticker(1, 10):  
  10.         print(i)  
  11.   
  12. loop = asyncio.get_event_loop()  
  13. try:  
  14.     loop.run_until_complete(run())  
  15. finally:  
  16.   
  17.     loop.close()  

 

 

 

 

順帶一提，yield 咱們能夠暫且認爲是一種中斷機制（詳情能夠參考官方文檔，這種解釋只是便於說明await）

例如：

 

[python]  view plain  copy
 
  1. def a():  
  2.     print("first")    
  3.     yield     
  4.     print("second")   
  5.     yield    
  6.     print("end")   
  7.     yield   
  8.   
  9. if __name__ == "__main__":  
  10.   
  11.     g1=a()  
  12.     print("next1")  
  13.     g1.__next__()  
  14.     print("next2")  
  15.     g1.__next__()  
  16.     print("next3")  
  17.     g1.__next__()  


 

 

 

 

②容許在協程函數中異步推導式

例如：

 

[python]  view plain  copy
 
  1. async def ticker(delay, to):  
  2.     for i in range(to):  
  3.         yield i  
  4.         await asyncio.sleep(delay)  
  5.   
  6. async def run():  
  7.     result = [i async for i in ticker(1, 10) if i%2]  
  8.     print(result)  
  9. import asyncio  
  10. loop = asyncio.get_event_loop()  
  11. try:  
  12.   
  13.     loop.run_until_complete(run())  
  14. finally:  
  15.   
  16.     loop.close()  


 

 

【六】協程併發

定義tasks時能夠設置多個ensure，也能夠像多線程那樣用append方法實現

 

[python]  view plain  copy
 
  1. tasks = [  
  2.     asyncio.ensure_future(coroutine1),  
  3.     asyncio.ensure_future(coroutine2),  
  4.     asyncio.ensure_future(coroutine3)  
  5. ]  
  6.   
  7. for i in range(4, 6):    
  8.     tasks.append(asyncio.ensure_future(do_some_work(i)))  



 

當遇到阻塞時可使用await讓其餘協程繼續工做

例如：

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4.    
  5. async def do_some_work(x):  
  6.     print('Waiting: ', x)  
  7.    
  8.     await asyncio.sleep(x)  
  9.     return 'Done after {}s'.format(x)  
  10.    
  11. coroutine1 = do_some_work(1)  
  12. coroutine2 = do_some_work(2)  
  13. coroutine3 = do_some_work(3)   
  14.   
  15. tasks = [  
  16.     asyncio.ensure_future(coroutine1),  
  17.     asyncio.ensure_future(coroutine2),  
  18.     asyncio.ensure_future(coroutine3)  
  19. ]  
  20.   
  21. for i in range(4, 6):    
  22.     tasks.append(asyncio.ensure_future(do_some_work(i)))  
  23.    
  24. loop = asyncio.get_event_loop()  
  25.   
  26. start = now()  
  27. loop.run_until_complete(asyncio.wait(tasks))  
  28.    
  29. for task in tasks:  
  30.     print('Task ret: ', task.result())  
  31.    
  32. print('TIME: ', now() - start)  


 

 

經過運行時間能夠看出aysncio實現了併發。asyncio.wait(tasks) 也可使用 asyncio.gather(*tasks) ,前者接受一個task列表，後者接收一堆task。

 

【七】協程嵌套

使用async能夠定義協程，協程用於耗時的io操做，咱們也能夠封裝更多的io操做過程，這樣就實現了嵌套的協程，即一個協程中await了另一個協程，如此鏈接起來。

 

例如：

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. async def do_some_work(x):  
  5.     print('Waiting: ', x)  
  6.    
  7.     await asyncio.sleep(x)  
  8.     return 'Done after {}s'.format(x)  
  9.    
  10. async def main():  
  11.     coroutine1 = do_some_work(1)  
  12.     coroutine2 = do_some_work(2)  
  13.     coroutine3 = do_some_work(4)  
  14.    
  15.     tasks = [  
  16.         asyncio.ensure_future(coroutine1),  
  17.         asyncio.ensure_future(coroutine2),  
  18.         asyncio.ensure_future(coroutine3)  
  19.     ]  
  20.    
  21.     dones, pendings = await asyncio.wait(tasks)  
  22.    
  23.     for task in dones:  
  24.         print('Task ret: ', task.result())  
  25.    
  26. start = now()  
  27.    
  28. loop = asyncio.get_event_loop()  
  29. loop.run_until_complete(main())  
  30.    
  31. print('TIME: ', now() - start)  



 

 

若是使用的是 asyncio.gather建立協程對象，那麼await的返回值就是協程運行的結果。

 

[python]  view plain  copy
 
  1. #dones, pendings = await asyncio.wait(tasks)  
  2.     #for task in dones:  
  3.     #print('Task ret: ', task.result())  
  4. results = await asyncio.gather(*tasks)  
  5. for result in results:  
  6.     print('Task ret: ', result)  



 

不在main協程函數裏處理結果，直接返回await的內容，那麼最外層的run_until_complete將會返回main協程的結果。

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. async def do_some_work(x):  
  5.     print('Waiting: ', x)  
  6.    
  7.     await asyncio.sleep(x)  
  8.     return 'Done after {}s'.format(x)  
  9.    
  10. async def main():  
  11.     coroutine1 = do_some_work(1)  
  12.     coroutine2 = do_some_work(2)  
  13.     coroutine3 = do_some_work(4)  
  14.    
  15.     tasks = [  
  16.         asyncio.ensure_future(coroutine1),  
  17.         asyncio.ensure_future(coroutine2),  
  18.         asyncio.ensure_future(coroutine3)  
  19.     ]  
  20.    
  21.     return await asyncio.gather(*tasks)  
  22.    
  23. start = now()  
  24. loop = asyncio.get_event_loop()  
  25. results = loop.run_until_complete(main())  
  26. for result in results:  
  27.     print('Task ret: ', result)  
  28.    
  29. print('TIME: ', now() - start)  



 

 

或者返回使用asyncio.wait方式掛起協程。

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. async def do_some_work(x):  
  5.     print('Waiting: ', x)  
  6.    
  7.     await asyncio.sleep(x)  
  8.     return 'Done after {}s'.format(x)  
  9.    
  10. async def main():  
  11.     coroutine1 = do_some_work(1)  
  12.     coroutine2 = do_some_work(2)  
  13.     coroutine3 = do_some_work(4)  
  14.    
  15.     tasks = [  
  16.         asyncio.ensure_future(coroutine1),  
  17.         asyncio.ensure_future(coroutine2),  
  18.         asyncio.ensure_future(coroutine3)  
  19.     ]  
  20.    
  21.     return await asyncio.wait(tasks)  
  22.    
  23. start = now()  
  24.    
  25. loop = asyncio.get_event_loop()  
  26. done, pending = loop.run_until_complete(main())  
  27.    
  28. for task in done:  
  29.     print('Task ret: ', task.result())  
  30.    
  31. print('TIME: ', now() - start)  


 

 

也可使用asyncio的as_completed方法

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. async def do_some_work(x):  
  5.     print('Waiting: ', x)  
  6.    
  7.     await asyncio.sleep(x)  
  8.     return 'Done after {}s'.format(x)  
  9.    
  10. async def main():  
  11.     coroutine1 = do_some_work(1)  
  12.     coroutine2 = do_some_work(2)  
  13.     coroutine3 = do_some_work(4)  
  14.    
  15.     tasks = [  
  16.         asyncio.ensure_future(coroutine1),  
  17.         asyncio.ensure_future(coroutine2),  
  18.         asyncio.ensure_future(coroutine3)  
  19.     ]  
  20.     for task in asyncio.as_completed(tasks):  
  21.         result = await task  
  22.         print('Task ret: {}'.format(result))  
  23.    
  24. start = now()  
  25.    
  26. loop = asyncio.get_event_loop()  
  27. done = loop.run_until_complete(main())  
  28. print('TIME: ', now() - start)  



 

因而可知，協程的調用和組合十分的靈活，咱們能夠發揮想象盡情的浪

 

【八】協程中止

future對象有幾個狀態：
Pending
Running
Done
Cancelled
建立future的時候，task爲pending，事件循環調用執行的時候固然就是running，調用完畢天然就是done，若是須要中止事件循環，就須要先把task取消。可使用asyncio.Task獲取事件循環的task

例如：

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4.    
  5. async def do_some_work(x):  
  6.     print('Waiting: ', x)  
  7.    
  8.     await asyncio.sleep(x)  
  9.     return 'Done after {}s'.format(x)  
  10.    
  11. coroutine1 = do_some_work(1)  
  12. coroutine2 = do_some_work(2)  
  13. coroutine3 = do_some_work(4)  
  14.    
  15. tasks = [  
  16.     asyncio.ensure_future(coroutine1),  
  17.     asyncio.ensure_future(coroutine2),  
  18.     asyncio.ensure_future(coroutine3)  
  19. ]  
  20.    
  21. start = now()  
  22.    
  23. loop = asyncio.get_event_loop()  
  24. try:  
  25.     loop.run_until_complete(asyncio.wait(tasks))  
  26. except KeyboardInterrupt as e:  
  27.     print(asyncio.Task.all_tasks())  
  28.     for task in asyncio.Task.all_tasks():  
  29.         print(task.cancel())  
  30.     loop.stop()  
  31.     loop.run_forever()  
  32. finally:  
  33.     loop.close()  
  34.    
  35. print('TIME: ', now() - start)  


啓動事件循環以後，立刻ctrl+c，會觸發run_until_complete的執行異常 KeyBorardInterrupt。而後經過循環asyncio.Task取消future

 

 

 

True表示cannel成功，loop stop以後還須要再次開啓事件循環，最後在close，否則會報錯。

 

循環task，逐個cancel是一種方案，但是正如上面咱們把task的列表封裝在main函數中，main函數外進行事件循環的調用。這個時候，main至關於最外出的一個task，那麼處理包裝的main函數便可。

 

 

[python]  view plain  copy
 
  1. import asyncio  
  2.    
  3. import time  
  4.    
  5. now = lambda: time.time()  
  6.    
  7. async def do_some_work(x):  
  8.     print('Waiting: ', x)  
  9.    
  10.     await asyncio.sleep(x)  
  11.     return 'Done after {}s'.format(x)  
  12.    
  13. async def main():  
  14.     coroutine1 = do_some_work(1)  
  15.     coroutine2 = do_some_work(2)  
  16.     coroutine3 = do_some_work(4)  
  17.    
  18.     tasks = [  
  19.         asyncio.ensure_future(coroutine1),  
  20.         asyncio.ensure_future(coroutine2),  
  21.         asyncio.ensure_future(coroutine3)  
  22.     ]  
  23.     done, pending = await asyncio.wait(tasks)  
  24.     for task in done:  
  25.         print('Task ret: ', task.result())  
  26.    
  27. start = now()  
  28.    
  29. loop = asyncio.get_event_loop()  
  30. task = asyncio.ensure_future(main())  
  31. try:  
  32.     loop.run_until_complete(task)  
  33. except KeyboardInterrupt as e:  
  34.     print(asyncio.Task.all_tasks())  
  35.     print(asyncio.gather(*asyncio.Task.all_tasks()).cancel())  
  36.     loop.stop()  
  37.     loop.run_forever()  
  38. finally:  
  39.     loop.close()  


 

 

【九】不一樣線程的事件循環

 

不少時候，咱們的事件循環用於註冊協程，而有的協程須要動態的添加到事件循環中。一個簡單的方式就是使用多線程。當前線程建立一個事件循環，而後在新建一個線程，在新線程中啓動事件循環。當前線程不會被block。

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. from threading import Thread  
  5.    
  6. def start_loop(loop):  
  7.     asyncio.set_event_loop(loop)  
  8.     loop.run_forever()  
  9.    
  10. def more_work(x):  
  11.     print('More work {}'.format(x))  
  12.     time.sleep(x)  
  13.     print('Finished more work {}'.format(x))  
  14.    
  15. start = now()  
  16. new_loop = asyncio.new_event_loop()  
  17. t = Thread(target=start_loop, args=(new_loop,))  
  18. t.start()  
  19. print('TIME: {}'.format(time.time() - start))  
  20.    
  21. new_loop.call_soon_threadsafe(more_work, 6)  
  22. new_loop.call_soon_threadsafe(more_work, 3)  

 

 

啓動上述代碼以後，當前線程不會被block，新線程中會按照順序執行call_soon_threadsafe方法註冊的more_work方法，後者由於time.sleep操做是同步阻塞的，所以運行完畢more_work須要大體6 + 3

 

 

【十】新線程協程

新線程協程的話，能夠在主線程中建立一個new_loop，而後在另外的子線程中開啓一個無限事件循環。主線程經過run_coroutine_threadsafe新註冊協程對象。這樣就能在子線程中進行事件循環的併發操做，同時主線程又不會被block。一共執行的時間大概在6s左右。

 

[python]  view plain  copy
 
  1. import asyncio  
  2. import time  
  3. now = lambda: time.time()  
  4. from threading import Thread  
  5.    
  6.   
  7. def start_loop(loop):  
  8.     asyncio.set_event_loop(loop)  
  9.     loop.run_forever()  
  10.    
  11. async def do_some_work(x):  
  12.     print('Waiting {}'.format(x))  
  13.     await asyncio.sleep(x)  
  14.     print('Done after {}s'.format(x))  
  15.    
  16. def more_work(x):  
  17.     print('More work {}'.format(x))  
  18.     time.sleep(x)  
  19.     print('Finished more work {}'.format(x))  
  20.    
  21. start = now()  
  22. new_loop = asyncio.new_event_loop()  
  23. t = Thread(target=start_loop, args=(new_loop,))  
  24. t.start()  
  25. print('TIME: {}'.format(time.time() - start))  
  26.    
  27. asyncio.run_coroutine_threadsafe(do_some_work(6), new_loop)  
  28. asyncio.run_coroutine_threadsafe(do_some_work(4), new_loop)  


相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程