主頁 > 後端開發 > asyncio異步編程【含視頻教程】

asyncio異步編程【含視頻教程】

2020-10-03 00:34:50 後端開發

不知道你是否發現，身邊聊異步的人越來越多了，比如：FastAPI、Tornado、Sanic、Django 3、aiohttp等，

聽說異步如何如何牛逼？性能如何吊炸天，，，，但他到底是咋回事呢？

本節要跟大家一起聊聊關于asyncio異步的那些事！

 

視頻教程：https://study.163.com/instructor/3525856.htm

wiki同步：https://pythonav.com/wiki/

 

1.協程

想學asyncio，得先了解協程，協程是根本呀！

協程（Coroutine），也可以被稱為微執行緒，是一種用戶態內的背景關系切換技術，簡而言之，其實就是通過一個執行緒實作代碼塊相互切換執行，例如：

def func1():
    print(1)
    ...
    print(2)
def func2():
    print(3)
    ...
    print(4)
func1()
func2()

上述代碼是普通的函式定義和執行，按流程分別執行兩個函式中的代碼，并先后會輸出：1、2、3、4，但如果介入協程技術那么就可以實作函式見代碼切換執行，最終輸入：1、3、2、4 ，

在Python中有多種方式可以實作協程，例如：

  • greenlet，是一個第三方模塊，用于實作協程代碼（Gevent協程就是基于greenlet實作）
  • yield，生成器，借助生成器的特點也可以實作協程代碼，
  • asyncio，在Python3.4中引入的模塊用于撰寫協程代碼，
  • async & awiat，在Python3.5中引入的兩個關鍵字，結合asyncio模塊可以更方便的撰寫協程代碼，

1.1 greenlet

greentlet是一個第三方模塊，需要提前安裝 pip3 install greenlet才能使用，

from greenlet import greenlet
def func1():
    print(1)        # 第1步：輸出 1
    gr2.switch()    # 第3步：切換到 func2 函式
    print(2)        # 第6步：輸出 2
    gr2.switch()    # 第7步：切換到 func2 函式，從上一次執行的位置繼續向后執行
def func2():
    print(3)        # 第4步：輸出 3
    gr1.switch()    # 第5步：切換到 func1 函式，從上一次執行的位置繼續向后執行
    print(4)        # 第8步：輸出 4
gr1 = greenlet(func1)
gr2 = greenlet(func2)
gr1.switch() # 第1步：去執行 func1 函式

注意：switch中也可以傳遞引數用于在切換執行時相互傳遞值，

1.2 yield

基于Python的生成器的yield和yield form關鍵字實作協程代碼，

def func1():
    yield 1
    yield from func2()
    yield 2
def func2():
    yield 3
    yield 4
f1 = func1()
for item in f1:
    print(item)

注意：yield form關鍵字是在Python3.3中引入的，

1.3 asyncio

在Python3.4之前官方未提供協程的類別庫，一般大家都是使用greenlet等其他來實作，在Python3.4發布后官方正式支持協程，即：asyncio模塊，

import asyncio
@asyncio.coroutine
def func1():
    print(1)
    yield from asyncio.sleep(2)  # 遇到IO耗時操作，自動化切換到tasks中的其他任務
    print(2)
@asyncio.coroutine
def func2():
    print(3)
    yield from asyncio.sleep(2) # 遇到IO耗時操作，自動化切換到tasks中的其他任務
    print(4)
tasks = [
    asyncio.ensure_future( func1() ),
    asyncio.ensure_future( func2() )
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

注意：基于asyncio模塊實作的協程比之前的要更厲害，因為他的內部還集成了遇到IO耗時操作自動切花的功能，

1.4 async & awit

async & awit 關鍵字在Python3.5版本中正式引入，基于他撰寫的協程代碼其實就是 上一示例 的加強版，讓代碼可以更加簡便，

Python3.8之后 @asyncio.coroutine 裝飾器就會被移除，推薦使用async & awit 關鍵字實作協程代碼，

import asyncio
async def func1():
    print(1)
    await asyncio.sleep(2)
    print(2)
async def func2():
    print(3)
    await asyncio.sleep(2)
    print(4)
tasks = [
    asyncio.ensure_future(func1()),
    asyncio.ensure_future(func2())
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

1.5 小結

關于協程有多種實作方式，目前主流使用是Python官方推薦的asyncio模塊和async&await關鍵字的方式，例如：在tonado、sanic、fastapi、django3 中均已支持，

接下來，我們也會針對 asyncio模塊 + async & await 關鍵字進行更加詳細的講解，

 

2.協程的意義

通過學習，我們已經了解到協程可以通過一個執行緒在多個背景關系中進行來回切換執行，

但是，協程來回切換執行的意義何在呢？（網上看到很多文章舔協程，協程牛逼之處是哪里呢？）

  1. 計算型的操作，利用協程來回切換執行，沒有任何意義，來回切換并保存狀態 反倒會降低性能，
  2. IO型的操作，利用協程在IO等待時間就去切換執行其他任務，當IO操作結束后再自動回呼，那么就會大大節省資源并提供性能，從而實作異步編程（不等待任務結束就可以去執行其他代碼），

2.1 爬蟲案例

例如：用代碼實作下載 url_list 中的圖片，

  • 方式一：同步編程實作
    """
下載圖片使用第三方模塊requests，請提前安裝：pip3 install requests
"""
import requests
def download_image(url):
    print("開始下載:",url)
    # 發送網路請求，下載圖片
    response = requests.get(url)
    print("下載完成")
    # 圖片保存到本地檔案
    file_name = url.rsplit('_')[-1]
    with open(file_name, mode='wb') as file_object:
        file_object.write(response.content)
if __name__ == '__main__':
    url_list = [
        'https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
        'https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg',
        'https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg'
    ]
    for item in url_list:
        download_image(item)
  • 方式二：基于協程的異步編程實作
    """
下載圖片使用第三方模塊aiohttp，請提前安裝：pip3 install aiohttp
"""
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import aiohttp
import asyncio
async def fetch(session, url):
    print("發送請求：", url)
    async with session.get(url, verify_ssl=False) as response:
        content = await response.content.read()
        file_name = url.rsplit('_')[-1]
        with open(file_name, mode='wb') as file_object:
            file_object.write(content)
async def main():
    async with aiohttp.ClientSession() as session:
        url_list = [
            'https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
            'https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg',
            'https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg'
        ]
        tasks = [asyncio.create_task(fetch(session, url)) for url in url_list]
        await asyncio.wait(tasks)
if __name__ == '__main__':
    asyncio.run(main())

上述兩種的執行對比之后會發現，基于協程的異步編程 要比 同步編程的效率高了很多，因為：

  • 同步編程，按照順序逐一排隊執行，如果圖片下載時間為2分鐘，那么全部執行完則需要6分鐘，
  • 異步編程，幾乎同時發出了3個下載任務的請求（遇到IO請求自動切換去發送其他任務請求），如果圖片下載時間為2分鐘，那么全部執行完畢也大概需要2分鐘左右就可以了，

2.2 小結

協程一般應用在有IO操作的程式中，因為協程可以利用IO等待的時間去執行一些其他的代碼，從而提升代碼執行效率，

生活中不也是這樣的么，假設 你是一家制造汽車的老板，員工點擊設備的【開始】按鈕之后，在設備前需等待30分鐘，然后點擊【結束】按鈕，此時作為老板的你一定希望這個員工在等待的那30分鐘的時間去做點其他的作業，

3.異步編程

基于async & await關鍵字的協程可以實作異步編程，這也是目前python異步相關的主流技術，

想要真正的了解Python中內置的異步編程，根據下文的順序一點點來看，

3.1 事件回圈

事件回圈，可以把他當做是一個while回圈，這個while回圈在周期性的運行并執行一些任務，在特定條件下終止回圈，

# 偽代碼
任務串列 = [ 任務1, 任務2, 任務3,... ]
while True:
    可執行的任務串列，已完成的任務串列 = 去任務串列中檢查所有的任務，將'可執行'和'已完成'的任務回傳
    for 就緒任務 in 已準備就緒的任務串列:
        執行已就緒的任務
    for 已完成的任務 in 已完成的任務串列:
        在任務串列中移除 已完成的任務
    如果 任務串列 中的任務都已完成，則終止回圈

在撰寫程式時候可以通過如下代碼來獲取和創建事件回圈，

import asyncio
loop = asyncio.get_event_loop()

3.2 協程和異步編程

協程函式，定義形式為 async def 的函式，

協程物件，呼叫 協程函式 所回傳的物件，

# 定義一個協程函式
async def func():
    pass
# 呼叫協程函式，回傳一個協程物件
result = func()

注意：呼叫協程函式時，函式內部代碼不會執行，只是會回傳一個協程物件，

3.2.1 基本應用

程式中，如果想要執行協程函式的內部代碼，需要 事件回圈 和 協程物件 配合才能實作，如：

import asyncio
async def func():
    print("協程內部代碼")
# 呼叫協程函式，回傳一個協程物件，
result = func()
# 方式一
# loop = asyncio.get_event_loop() # 創建一個事件回圈
# loop.run_until_complete(result) # 將協程當做任務提交到事件回圈的任務串列中，協程執行完成之后終止，
# 方式二
# 本質上方式一是一樣的，內部先 創建事件回圈 然后執行 run_until_complete，一個簡便的寫法，
# asyncio.run 函式在 Python 3.7 中加入 asyncio 模塊，
asyncio.run(result)

這個程序可以簡單理解為：將協程當做任務添加到 事件回圈 的任務串列，然后事件回圈檢測串列中的協程是否 已準備就緒（默認可理解為就緒狀態），如果準備就緒則執行其內部代碼，

3.2.2 await

await是一個只能在協程函式中使用的關鍵字，用于遇到IO操作時掛起 當前協程（任務），當前協程（任務）掛起程序中 事件回圈可以去執行其他的協程（任務），當前協程IO處理完成時，可以再次切換回來執行await之后的代碼，代碼如下：

示例1：

import asyncio
async def func():
    print("執行協程函式內部代碼")
    # 遇到IO操作掛起當前協程（任務），等IO操作完成之后再繼續往下執行，
    # 當前協程掛起時，事件回圈可以去執行其他協程（任務），
    response = await asyncio.sleep(2)
    print("IO請求結束，結果為：", response)
result = func()
asyncio.run(result)

示例2：

import asyncio
async def others():
    print("start")
    await asyncio.sleep(2)
    print('end')
    return '回傳值'
async def func():
    print("執行協程函式內部代碼")
    # 遇到IO操作掛起當前協程（任務），等IO操作完成之后再繼續往下執行，當前協程掛起時，事件回圈可以去執行其他協程（任務），
    response = await others()
    print("IO請求結束，結果為：", response)
asyncio.run( func() )

示例3：

import asyncio
async def others():
    print("start")
    await asyncio.sleep(2)
    print('end')
    return '回傳值'
async def func():
    print("執行協程函式內部代碼")
    # 遇到IO操作掛起當前協程（任務），等IO操作完成之后再繼續往下執行，當前協程掛起時，事件回圈可以去執行其他協程（任務），
    response1 = await others()
    print("IO請求結束，結果為：", response1)
    response2 = await others()
    print("IO請求結束，結果為：", response2)
asyncio.run( func() )

上述的所有示例都只是創建了一個任務，即：事件回圈的任務串列中只有一個任務，所以在IO等待時無法演示切換到其他任務效果，

在程式想要創建多個任務物件，需要使用Task物件來實作，

3.2.3 Task物件

Tasks are used to schedule coroutines concurrently.

When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon，

Tasks用于并發調度協程，通過asyncio.create_task(協程物件)的方式創建Task物件，這樣可以讓協程加入事件回圈中等待被調度執行，除了使用 asyncio.create_task() 函式以外，還可以用低層級的 loop.create_task() 或 ensure_future() 函式，不建議手動實體化 Task 物件，

本質上是將協程物件封裝成task物件，并將協程立即加入事件回圈，同時追蹤協程的狀態，

注意：asyncio.create_task() 函式在 Python 3.7 中被加入，在 Python 3.7 之前，可以改用低層級的 asyncio.ensure_future() 函式，

示例1：

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "回傳值"
async def main():
    print("main開始")
    # 創建協程，將協程封裝到一個Task物件中并立即添加到事件回圈的任務串列中，等待事件回圈去執行（默認是就緒狀態），
    task1 = asyncio.create_task(func())
    # 創建協程，將協程封裝到一個Task物件中并立即添加到事件回圈的任務串列中，等待事件回圈去執行（默認是就緒狀態），
    task2 = asyncio.create_task(func())
    print("main結束")
    # 當執行某協程遇到IO操作時，會自動化切換執行其他任務，
    # 此處的await是等待相對應的協程全都執行完畢并獲取結果
    ret1 = await task1
    ret2 = await task2
    print(ret1, ret2)
asyncio.run(main())

示例2：

import asyncio
async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "回傳值"
async def main():
    print("main開始")
    # 創建協程，將協程封裝到Task物件中并添加到事件回圈的任務串列中，等待事件回圈去執行（默認是就緒狀態），
    # 在呼叫
    task_list = [
        asyncio.create_task(func(), name="n1"),
        asyncio.create_task(func(), name="n2")
    ]
    print("main結束")
    # 當執行某協程遇到IO操作時，會自動化切換執行其他任務，
    # 此處的await是等待所有協程執行完畢，并將所有協程的回傳值保存到done
    # 如果設定了timeout值，則意味著此處最多等待的秒，完成的協程回傳值寫入到done中，未完成則寫到pending中，
    done, pending = await asyncio.wait(task_list, timeout=None)
    print(done, pending)
asyncio.run(main())

注意：asyncio.wait 原始碼內部會對串列中的每個協程執行ensure_future從而封裝為Task物件，所以在和wait配合使用時task_list的值為[func(),func()] 也是可以的，

示例3：

import asyncio
async def func():
    print("執行協程函式內部代碼")
    # 遇到IO操作掛起當前協程（任務），等IO操作完成之后再繼續往下執行，當前協程掛起時，事件回圈可以去執行其他協程（任務），
    response = await asyncio.sleep(2)
    print("IO請求結束，結果為：", response)
coroutine_list = [func(), func()]
# 錯誤：coroutine_list = [ asyncio.create_task(func()), asyncio.create_task(func()) ]  
# 此處不能直接 asyncio.create_task，因為將Task立即加入到事件回圈的任務串列，
# 但此時事件回圈還未創建，所以會報錯，
# 使用asyncio.wait將串列封裝為一個協程，并呼叫asyncio.run實作執行兩個協程
# asyncio.wait內部會對串列中的每個協程執行ensure_future，封裝為Task物件，
done,pending = asyncio.run( asyncio.wait(coroutine_list) )

3.2.4 asyncio.Future物件

A Futureis a special low-level awaitable object that represents an eventual result of an asynchronous operation.

asyncio中的Future物件是一個相對更偏向底層的可物件，通常我們不會直接用到這個物件，而是直接使用Task物件來完成任務的并和狀態的追蹤，（ Task 是 Futrue的子類 ）

Future為我們提供了異步編程中的 最終結果 的處理（Task類也具備狀態處理的功能），

示例1：

async def main():
    # 獲取當前事件回圈
    loop = asyncio.get_running_loop()
    # # 創建一個任務（Future物件），這個任務什么都不干，
    fut = loop.create_future()
    # 等待任務最終結果（Future物件），沒有結果則會一直等下去，
    await fut
asyncio.run(main())

示例2：

import asyncio
async def set_after(fut):
    await asyncio.sleep(2)
    fut.set_result("666")
async def main():
    # 獲取當前事件回圈
    loop = asyncio.get_running_loop()
    # 創建一個任務（Future物件），沒系結任何行為，則這個任務永遠不知道什么時候結束，
    fut = loop.create_future()
    # 創建一個任務（Task物件），系結了set_after函式，函式內部在2s之后，會給fut賦值，
    # 即手動設定future任務的最終結果，那么fut就可以結束了，
    await loop.create_task(set_after(fut))
    # 等待 Future物件獲取 最終結果，否則一直等下去
    data = https://www.cnblogs.com/wupeiqi/p/await fut
    print(data)
asyncio.run(main())

Future物件本身函式進行系結，所以想要讓事件回圈獲取Future的結果，則需要手動設定，而Task物件繼承了Future物件，其實就對Future進行擴展，他可以實作在對應系結的函式執行完成之后，自動執行set_result，從而實作自動結束，

雖然，平時使用的是Task物件，但對于結果的處理本質是基于Future物件來實作的，

擴展：支持 await 物件語 法的物件課成為可等待物件，所以 協程物件、Task物件、Future物件 都可以被成為可等待物件，

3.2.5 futures.Future物件

在Python的concurrent.futures模塊中也有一個Future物件，這個物件是基于執行緒池和行程池實作異步操作時使用的物件，

port time
from concurrent.futures import Future
from concurrent.futures.thread import ThreadPoolExecutor
from concurrent.futures.process import ProcessPoolExecutor
def func(value):
    time.sleep(1)
    print(value)
pool = ThreadPoolExecutor(max_workers=5)
# 或 pool = ProcessPoolExecutor(max_workers=5)
for i in range(10):
    fut = pool.submit(func, i)
    print(fut)

兩個Future物件是不同的，他們是為不同的應用場景而設計，例如：concurrent.futures.Future不支持await語法 等，

官方提示兩物件之間不同：

  • unlike asyncio Futures, concurrent.futures.Future instances cannot be awaited.

  • asyncio.Future.result() and asyncio.Future.exception() do not accept the timeout argument.

  • asyncio.Future.result() and asyncio.Future.exception() raise an InvalidStateError exception when the Future is not done.
  • Callbacks registered with asyncio.Future.add_done_callback() are not called immediately. They are scheduled with loop.call_soon() instead.
  • asyncio Future is not compatible with the concurrent.futures.wait() and concurrent.futures.as_completed() functions.

在Python提供了一個將futures.Future 物件包裝成asyncio.Future物件的函式 asynic.wrap_future，

接下里你肯定問：為什么python會提供這種功能？

其實，一般在程式開發中我們要么統一使用 asycio 的協程實作異步操作、要么都使用行程池和執行緒池實作異步操作，但如果 協程的異步和 行程池/執行緒池的異步 混搭時，那么就會用到此功能了，

import time
import asyncio
import concurrent.futures
def func1():
    # 某個耗時操作
    time.sleep(2)
    return "SB"
async def main():
    loop = asyncio.get_running_loop()
    # 1. Run in the default loop's executor ( 默認ThreadPoolExecutor )
    # 第一步：內部會先呼叫 ThreadPoolExecutor 的 submit 方法去執行緒池中申請一個執行緒去執行func1函式，并回傳一個concurrent.futures.Future物件
    # 第二步：呼叫asyncio.wrap_future將concurrent.futures.Future物件包裝為asycio.Future物件，
    # 因為concurrent.futures.Future物件不支持await語法，所以需要包裝為 asycio.Future物件 才能使用，
    fut = loop.run_in_executor(None, func1)
    result = await fut
    print('default thread pool', result)
    # 2. Run in a custom thread pool:
    # with concurrent.futures.ThreadPoolExecutor() as pool:
    #     result = await loop.run_in_executor(
    #         pool, func1)
    #     print('custom thread pool', result)
    # 3. Run in a custom process pool:
    # with concurrent.futures.ProcessPoolExecutor() as pool:
    #     result = await loop.run_in_executor(
    #         pool, func1)
    #     print('custom process pool', result)
asyncio.run(main())

應用場景：當專案以協程式的異步編程開發時，如果要使用一個第三方模塊，而第三方模塊不支持協程方式異步編程時，就需要用到這個功能，例如：

import asyncio
import requests
async def download_image(url):
    # 發送網路請求，下載圖片（遇到網路下載圖片的IO請求，自動化切換到其他任務）
    print("開始下載:", url)
    loop = asyncio.get_event_loop()
    # requests模塊默認不支持異步操作，所以就使用執行緒池來配合實作了，
    future = loop.run_in_executor(None, requests.get, url)
    response = await future
    print('下載完成')
    # 圖片保存到本地檔案
    file_name = url.rsplit('_')[-1]
    with open(file_name, mode='wb') as file_object:
        file_object.write(response.content)
if __name__ == '__main__':
    url_list = [
        'https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120x90_0_autohomecar__ChsEe12AXQ6AOOH_AAFocMs8nzU621.jpg',
        'https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120x90_0_autohomecar__ChcCSV2BBICAUntfAADjJFd6800429.jpg',
        'https://www3.autoimg.cn/newsdfs/g26/M0B/3C/65/120x90_0_autohomecar__ChcCP12BFCmAIO83AAGq7vK0sGY193.jpg'
    ]
    tasks = [download_image(url) for url in url_list]
    loop = asyncio.get_event_loop()
    loop.run_until_complete( asyncio.wait(tasks) )

3.2.6 異步迭代器

什么是異步迭代器

實作了 __aiter__() 和 __anext__() 方法的物件，__anext__ 必須回傳一個 awaitable 物件，async for 會處理異步迭代器的 __anext__() 方法所回傳的可等待物件，直到其引發一個 StopAsyncIteration 例外，由 PEP 492 引入，

什么是異步可迭代物件？

可在 async for 陳述句中被使用的物件，必須通過它的 __aiter__() 方法回傳一個 asynchronous iterator，由 PEP 492 引入，

import asyncio
class Reader(object):
    """ 自定義異步迭代器（同時也是異步可迭代物件） """
    def __init__(self):
        self.count = 0
    async def readline(self):
        # await asyncio.sleep(1)
        self.count += 1
        if self.count == 100:
            return None
        return self.count
    def __aiter__(self):
        return self
    async def __anext__(self):
        val = await self.readline()
        if val == None:
            raise StopAsyncIteration
        return val
async def func():
    # 創建異步可迭代物件
    async_iter = Reader()
    # async for 必須要放在async def函式內，否則語法錯誤，
    async for item in async_iter:
        print(item)
asyncio.run(func())

異步迭代器其實沒什么太大的作用，只是支持了async for語法而已，

3.2.6 異步背景關系管理器

此種物件通過定義 __aenter__() 和 __aexit__() 方法來對 async with 陳述句中的環境進行控制，由 PEP 492 引入，

import asyncio
class AsyncContextManager:
    def __init__(self):
        self.conn = conn
    async def do_something(self):
        # 異步操作資料庫
        return 666
    async def __aenter__(self):
        # 異步鏈接資料庫
        self.conn = await asyncio.sleep(1)
        return self
    async def __aexit__(self, exc_type, exc, tb):
        # 異步關閉資料庫鏈接
        await asyncio.sleep(1)
async def func():
    async with AsyncContextManager() as f:
        result = await f.do_something()
        print(result)
asyncio.run(func())

這個異步的背景關系管理器還是比較有用的，平時在開發程序中 打開、處理、關閉 操作時，就可以用這種方式來處理，

3.3 小結

在程式中只要看到async和await關鍵字，其內部就是基于協程實作的異步編程，這種異步編程是通過一個執行緒在IO等待時間去執行其他任務，從而實作并發，

以上就是異步編程的常見操作，內容參考官方檔案，

  • 中文版：https://docs.python.org/zh-cn/3.8/library/asyncio.html
  • 英文本：https://docs.python.org/3.8/library/asyncio.html

4. uvloop

Python標準庫中提供了asyncio模塊，用于支持基于協程的異步編程，

uvloop是 asyncio 中的事件回圈的替代方案，替換后可以使得asyncio性能提高，事實上，uvloop要比nodejs、gevent等其他python異步框架至少要快2倍，性能可以比肩Go語言，

安裝uvloop

pip3 install uvloop

在專案中想要使用uvloop替換asyncio的事件回圈也非常簡單，只要在代碼中這么做就行，

import asyncio
import uvloop
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
# 撰寫asyncio的代碼，與之前寫的代碼一致，
# 內部的事件回圈自動化會變為uvloop
asyncio.run(...)

注意：知名的asgi uvicorn內部就是使用的uvloop的事件回圈，

5.實戰案例

為了更好理解，上述所有示例的IO情況都是以 asyncio.sleep 為例，而真實的專案開發中會用到很多IO的情況，

5.1 異步Redis

當通過python去操作redis時，鏈接、設定值、獲取值 這些都涉及網路IO請求，使用asycio異步的方式可以在IO等待時去做一些其他任務，從而提升性能，

安裝Python異步操作redis模塊

pip3 install aioredis

示例1：異步操作redis，

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import asyncio
import aioredis
async def execute(address, password):
    print("開始執行", address)
    # 網路IO操作：創建redis連接
    redis = await aioredis.create_redis(address, password=password)
    # 網路IO操作：在redis中設定哈希值car，內部在設三個鍵值對，即： redis = { car:{key1:1,key2:2,key3:3}}
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)
    # 網路IO操作：去redis中獲取值
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)
    redis.close()
    # 網路IO操作：關閉redis連接
    await redis.wait_closed()
    print("結束", address)
asyncio.run(execute('redis://47.93.4.198:6379', "root!2345"))

示例2：連接多個redis做操作（遇到IO會切換其他任務，提供了性能），

import asyncio
import aioredis
async def execute(address, password):
    print("開始執行", address)
    # 網路IO操作：先去連接 47.93.4.197:6379，遇到IO則自動切換任務，去連接47.93.4.198:6379
    redis = await aioredis.create_redis_pool(address, password=password)
    # 網路IO操作：遇到IO會自動切換任務
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)
    # 網路IO操作：遇到IO會自動切換任務
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)
    redis.close()
    # 網路IO操作：遇到IO會自動切換任務
    await redis.wait_closed()
    print("結束", address)
task_list = [
    execute('redis://47.93.4.197:6379', "root!2345"),
    execute('redis://47.93.4.198:6379', "root!2345")
]
asyncio.run(asyncio.wait(task_list))

更多redis操作參考aioredis官網：https://aioredis.readthedocs.io/en/v1.3.0/start.html

5.2 異步MySQL

當通過python去操作MySQL時，連接、執行SQL、關閉都涉及網路IO請求，使用asycio異步的方式可以在IO等待時去做一些其他任務，從而提升性能，

安裝Python異步操作redis模塊

pip3 install aiomysql

示例1：

import asyncio
import aiomysql
async def execute():
    # 網路IO操作：連接MySQL
    conn = await aiomysql.connect(host='127.0.0.1', port=3306, user='root', password='123', db='mysql', )
    # 網路IO操作：創建CURSOR
    cur = await conn.cursor()
    # 網路IO操作：執行SQL
    await cur.execute("SELECT Host,User FROM user")
    # 網路IO操作：獲取SQL結果
    result = await cur.fetchall()
    print(result)
    # 網路IO操作：關閉鏈接
    await cur.close()
    conn.close()
asyncio.run(execute())

示例2：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import asyncio
import aiomysql
async def execute(host, password):
    print("開始", host)
    # 網路IO操作：先去連接 47.93.40.197，遇到IO則自動切換任務，去連接47.93.40.198:6379
    conn = await aiomysql.connect(host=host, port=3306, user='root', password=password, db='mysql')
    # 網路IO操作：遇到IO會自動切換任務
    cur = await conn.cursor()
    # 網路IO操作：遇到IO會自動切換任務
    await cur.execute("SELECT Host,User FROM user")
    # 網路IO操作：遇到IO會自動切換任務
    result = await cur.fetchall()
    print(result)
    # 網路IO操作：遇到IO會自動切換任務
    await cur.close()
    conn.close()
    print("結束", host)
task_list = [
    execute('47.93.40.197', "root!2345"),
    execute('47.93.40.197', "root!2345")
]
asyncio.run(asyncio.wait(task_list))

5.3 FastAPI框架

FastAPI是一款用于構建API的高性能web框架，框架基于Python3.6+的 type hints搭建，

接下里的異步示例以FastAPI和uvicorn來講解（uvicorn是一個支持異步的asgi），

安裝FastAPI web 框架，

pip3 install fastapi

安裝uvicorn，本質上為web提供socket server的支持的asgi（一般支持異步稱asgi、不支持異步稱wsgi）

pip3 install uvicorn

示例：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import asyncio
import uvicorn
import aioredis
from aioredis import Redis
from fastapi import FastAPI
app = FastAPI()
REDIS_POOL = aioredis.ConnectionsPool('redis://47.193.14.198:6379', password="root123", minsize=1, maxsize=10)
@app.get("/")
def index():
    """ 普通操作介面 """
    return {"message": "Hello World"}
@app.get("/red")
async def red():
    """ 異步操作介面 """
    print("請求來了")
    await asyncio.sleep(3)
    # 連接池獲取一個連接
    conn = await REDIS_POOL.acquire()
    redis = Redis(conn)
    # 設定值
    await redis.hmset_dict('car', key1=1, key2=2, key3=3)
    # 讀取值
    result = await redis.hgetall('car', encoding='utf-8')
    print(result)
    # 連接歸還連接池
    REDIS_POOL.release(conn)
    return result
if __name__ == '__main__':
    uvicorn.run("luffy:app", host="127.0.0.1", port=5000, log_level="info")

在有多個用戶并發請求的情況下，異步方式來撰寫的介面可以在IO等待程序中去處理其他的請求，提供性能，

例如：同時有兩個用戶并發來向介面 http://127.0.0.1:5000/red 發送請求，服務端只有一個執行緒，同一時刻只有一個請求被處理， 異步處理可以提供并發是因為：當視圖函式在處理第一個請求時，第二個請求此時是等待被處理的狀態，當第一個請求遇到IO等待時，會自動切換去接收并處理第二個請求，當遇到IO時自動化切換至其他請求，一旦有請求IO執行完畢，則會再次回到指定請求向下繼續執行其功能代碼，

5.4 爬蟲

在撰寫爬蟲應用時，需要通過網路IO去請求目標資料，這種情況適合使用異步編程來提升性能，接下來我們使用支持異步編程的aiohttp模塊來實作，

安裝aiohttp模塊

pip3 install aiohttp

示例：

import aiohttp
import asyncio
async def fetch(session, url):
    print("發送請求：", url)
    async with session.get(url, verify_ssl=False) as response:
        text = await response.text()
        print("得到結果：", url, len(text))
async def main():
    async with aiohttp.ClientSession() as session:
        url_list = [
            'https://python.org',
            'https://www.baidu.com',
            'https://www.pythonav.com'
        ]
        tasks = [asyncio.create_task(fetch(session, url)) for url in url_list]
        await asyncio.wait(tasks)
if __name__ == '__main__':
    asyncio.run(main())

總結

為了提升性能越來越多的框架都在向異步編程靠攏，例如：sanic、tornado、django3.0、django channels組件 等，用更少資源可以做處理更多的事，何樂而不為呢，

 

　　

 

 

　　

 

 

 

 

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/149786.html

標籤：Python

上一篇：手把手教你使用ADB卸載手機內置App軟體

下一篇：Tkinter的Canvas組件

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂