Python异步编程_asyncio

1.协程

协程不是计算机提供的，它是程序员创造的。

协程-Co_routine，也可以称之为微线程，是一种用户态内的上下文切换技术，简而言之，其实就是通过一个线程实现代码块相互切换执行。

实现协程的几种方法：

greenlet，早期模块
yield关键字
asyncio装饰器(python3.4及其之后)
async、await关键字(python3.5及其之后)【推荐】

1.1 greenlet实现协程

pip3 install greenlet

from greenlet import greenlet def func1(): print(1) # step1: output 1 gr2.switch() # step3: switch to function func2 print(2) # step6: output 2 gr2.switch() # step7: 切换到func2函数，从上一次执行的位置继续向后执行 def func2(): print(3) # step4: output 3 gr1.switch() # step3: 切换到func1函数，从上一次执行的位置继续向后执行 print(4) # step6: output 4 gr1 = greenlet(func1) gr2 = greenlet(func2) gr1.switch() # step1: 去执行func1函数

1.2 yield关键字

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

1.3 asyncio

在python3.4及其之后的版本支持

import asyncio @asyncio.corountine def func1(): print(1) yield from asyncio.sleep(2) # 遇到io耗时操作，自动化切换到tasks中的其他任务 print(2) @asyncio.corountine 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))

注意：遇到io阻塞的时候会自动切换，此时线程并没有闲着，一直在执行任务。

1.4 async & await 关键字

在python3.5及其以后版本

import asyncio async def func1(): print(1) await asyncio.sleep(2) # 遇到io耗时操作，自动化切换到tasks中的其他任务 print(2) async def func2(): print(3) await 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))

2.协程的意义

充分的利用线程，不让线程出现阻塞从而浪费硬件资源，同时耗费更少的时间去完成任务。

3.异步编程

3.1 事件循环

一个死循环，去检测并执行某些代码7

# 伪代码： 任务列表 = [任务1, 任务2, 任务3, ...] while True: 可执行的任务列表， 已完成的任务列表 = 去任务列表中检查所有的任务，将‘可执行’和‘已完成’的任务返回 for 就绪任务 in 可执行任务列表: 执行已就绪的任务 for 已完成的任务 in 已完成的任务列表: 在任务列表中移除 已完成任务 如果 任务列表中的任务都已完成，则终止循环

import asyncio # 去生成或获取一个时间循环 loop = asyncio.get_event_loop() # 将任务放到'任务列表' loop.run_until_complete(任务)

3.2 快速上手

首先了解2个定义：

协程函数——定义函数的时候async def 函数名

协程对象——执行协程函数()得到的协程对象

import asyncio async def func(): pass res = func() # 注意，执行协程函数创建协程对象，函数内部代码不执行，只是生成了一个协程对象res # 如果想要运行协程函数的内部代码，则需要将协程对象res交给事件循环来处理 loop = asyncio.get_event_loop() loop.run_until_complete(res) # asyncio.run(res) # python3.7及其以上版本(可以使用1行代替上面2行代码)

3.3 await

await + 可等待对象（协程对象、Future对象、Task对象）

示例1：

import asyncio asyncio def func(): print("来玩呀！") response = await asyncio.sleep(2) print("结束", response) loop = asyncio.get_event_loop() loop.run_until_complete(func())

示例2：

import asyncio async def others(): print("start") await asyncio.sleep(2) print("end") return("others 返回值") async def func(): print("协程函数func内部代码开始执行") # 遇到io操作挂起当前协程(任务)，等io操作完成之后再继续往下执行，当前协程挂起时，事件循环可以去执行其他协程(任务)。 response = await others() print("io 请求结束，结果为：", response) loop = asyncio.get_event_loop() loop.run_until_complete(func())

await就是等待对象的值(协程对象对应的函数执行完毕后的返回值)得到之后再继续往下走

3.4 Task对象

在事件中添加多个任务

Task用于并发调度协程，通过asyncio.create_task(协程对象)得法方式创建Task对象，这样就可以让协程加入事件循环中等待被调度执行。除使用asyncio.create_task()函数以外，还可以用低层级的loop.create_task()或asyncio.ensure_future()函数。不建议手动实例化Task对象。

注意：asyncio.create_task()函数在python3.7中被加入，所以在python3.7之前，可以改用低层级的asyncio.ensure_task()函数。

示例 1：

3.5 Future对象

Task继承Future，Task对象内部await结果的处理是基于Future对象来处理的，它是一种底层的应用，一般不会使用Future而是直接使用Task

import asyncio async def set_after(fut): await asyncio.sleep(2) fut.set_result("666") async def main(): # 获取当前 事件循环 loop = asyncio._get_running_loop() # python3,7以下 # loop = asyncio.get_running_loop() # python3,7及其以上 # 创建一个任务(Future obj)，没绑定任何行为，则这个任务会夯住 fut = loop.create_future() # 创建一个任务(Task obj)，绑定了set_after函数，函数内部在2s之后，会给fut的结果赋值。手动设置了fut任务的最终结果，那么fut得到了结果就会结束阻塞，继续执行下一段代码。 await loop.create_task(set_after(fut)) # 等待Future obj 获取最终结果，否则会一直阻塞下去 data = await fut print(data) loop = asyncio.get_event_loop() loop.run_until_complete(main())

3.5.1 扩展：concurrent.futures.Future对象

使用线程池、进程池实现异步操作的时候用到的对象

以后写代码可能会存在的交叉时间，例如：crm项目80%都是基于协程异步编程 + 某些模块(不支持)的时候，那么我们就可以使用进程池或者线程池来做到该某块的异步编程

def func1(): # 某个耗时操作 time.sleep(1) return "func1" async def main(): loop = asyncio._get_running_loop() # loop = asyncio.get_running_loop() # >=python3.7 required # 1. run in the default loop's executor (默认ThreadPoolExecutor) # 第一步：内部会先调用ThreadPoolExecutor的submit方法去线程池中申请一个线程去执行func1函数， # 并返回一个concurrent.futures.Future对象 # 第二步：调用asyncio.wrap_future将concurrent.futures.Future对象包装成asyncio.Future对象。 # 因为concurrent.futures.Future对象不支持await语法，所以需要包装为asyncio.Future对象才能使用。 fut = loop.run_in_executor(None, func1) res = await fut print("default thread pool =>", res) """" # 2. run in a custom thread pool: with futures.ThreadPoolExecutor() as pool: res = await loop.run_in_executor(pool, func1) print("custom thread pool =>", res) # 3 run in a custom process pool: with futures.ProcessPoolExecutor() as pool: res = await loop.run_in_executor(pool, func1) print("custom process pool =>", res) """ loop = asyncio.get_event_loop() loop.run_until_complete(main()) # asyncio.run(main()) # >=python3.7 required

在使用新的框架时候，有些模块更新的比较慢，当他不支持asyncio时候就可以使用线程池来实现该模块的异步编程

案例：asyncio + 不支持异步的模块

import asyncio import requests async def get_image(url): # 发送网络请求，下载图片（遇到网络下载io请求，自动化切换到其他下载任务） print("开始下载图片[%s]" % 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, 'wb') as f: f.write(response.content) if __name__ == '__main__': url_list = [ 'https://image11.m1905.cn/uploadfile/2019/0128/20190128095016853342.jpg', 'https://image11.m1905.cn/uploadfile/2019/0114/20190114103749971987.jpg', 'https://image11.m1905.cn/uploadfile/2018/1224/20181224014901948964.jpg', 'https://image11.m1905.cn/uploadfile/2018/0921/20180921031119509766.jpg', 'https://image11.m1905.cn/uploadfile/2018/1116/20181116095705863204.jpg' ] tasks = [get_image(url) for url in url_list] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(tasks))

3.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): 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 not val: raise StopAsyncIteration return val async def main(): # 注意：async for不能单独使用，必须嵌套在协程函数中使用 obj = Reader() async for item in obj: # 注意for循环内部实现机制 print(item) loop = asyncio.get_event_loop() loop.run_until_complete(main())

.7 异步上下文管理器

此种对象通过定义__aenter__()和__aexit__()方法来对async with语句中的环境进行控制，由PEP492引入。

import asyncio class AsyncHandleMysql: def __init__(self): self.conn = None async def do_something(self): # 这里可以异步操作数据库 return 666 async def __aenter__(self): # 这里可以异步连接数据库 self.conn = await asyncio.sleep(2) return self async def __aexit__(self, exc_type, exc_val, exc_tb): # 操作完数据库之后异步关闭数据库 await asyncio.sleep(1) async def main(): async with AsyncHandleMysql() as f: # __aenter__返回什么等于f res = await f.do_something() print(res) loop = asyncio.get_event_loop() loop.run_until_complete(main())

4.uvloop

asyncio的事件循环的替代方案，它的事件循环效率是高出python自带的事件循环效率不少。

使用方法：

安装：pip install uvloop

使用：

import asyncio import uvloop asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) # 将loop替换成uvloop # 然后下面的的编写asyncio代码不变就可以了 # 内部事件循环会自动变成uvloop loop = asyncio.get_event_loop() loop.run_until_complete(...) # asyncio.run(...)

引申：在Django3.0或者FastApi框架中使用了asgi,而asgi之所以快是使用了uvicorn,其实uvicorn底层就是使用的uvloop作为事件循环

5.实战案例

5.1 异步操作redis => aioredis

首先，redis要实现异步操作需要安装模块：pip install aioredis

然后具体使用示例如下：

import asyncio import aioredis async def execute(host, pwd): print("开始执行", host) # 网络io操作，先去连接 171.113.244.53:6379，遇到io则自动切换任务， # 去连接171.113.244.54:6379 redis = await aioredis.create_redis_pool(host, password=pwd) # 网络io操作，遇到io会自动切换任务 await redis.hmset_dict("car", key1="BMW", key2="BenZ") # 网络io操作，遇到io会自动切换任务 result = await redis.hgetall("car", encoding="utf-8") print(result) redis.close() # 网络io操作，遇到io自动切换任务 await redis.wait_closed() print("结束", host) task_list = [ execute('redis://171.113.244.53:6379', '12345'), execute('redis://171.113.244.54:6379', '67890') ] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(task_list))

5.2 异步操作MySQL => aiomysql

首先，MySQL要实现异步操作需要安装模块：pip install aiomysql

然后具体使用示例如下：

import asyncio import aiomysql async def execute(host, password): print("开始", host) conn = await aiomysql.connect( host=host, port=3306, user='root', password=password, db='asyncio_db' ) cur = await conn.cursor() await cur.execute("select * from user") result = await cur.fetchall() print(result) await cur.close() conn.close() print("结束", host) task_list = [ execute('171.113.244.53', '12345'), execute('171.113.244.54', '12345') ] loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(task_list))

5.3 FastAPI框架异步编程

安装

pip install fastapi pip install uvicorn

# _*_ coding: utf-8 _*_ # @Date : 2020/5/30 11:25 # @File : test_fastapi_async.py import asyncio import uvicorn import aioredis from aioredis import Redis from fastapi import FastAPI app = FastAPI() # 创建一个redis连接池 REDIS_POOL = aioredis.ConnectionsPool( 'redis://127.0.0.1:6379', # password='12345', minsize=1, maxsize=10) @app.get('/') def index(): "普通操作接口" return {"message": "Normal Api Index Geted"} @app.get('/async_test') async def async_test(): "异步操作接口" print("请求来了") await asyncio.sleep(2) # 从redis连接池中获取一个连接 conn = await REDIS_POOL.acquire() redis = Redis(conn) # 设置值 await redis.hmset_dict("book", key1="三国演义", key2="红楼梦", key3="西游记") # 读取值 result = await redis.hgetall('book', encoding="utf-8") print(result) # 归还连接到redis连接池 REDIS_POOL.release(conn) return result if __name__ == '__main__': uvicorn.run("test_fastapi_async:app", # test_fastapi_async是代码所在py文件名 host='127.0.0.1', port=5000, log_level='info' )

5.4 异步爬虫 => aiohttp

pip 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("得到[%s]结果:" % url, len(text)) async def main(): async with aiohttp.ClientSession() as session: url_list = [ 'https://www.chiphell.com/', 'http://www.baidu.com', 'http://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()) loop = asyncio.get_event_loop() loop.run_until_complete(main()) # 结果： 发送请求: https://www.chiphell.com/ 发送请求: http://www.baidu.com 发送请求: http://www.pythonav.com 得到[http://www.baidu.com]结果: 8074 得到[https://www.chiphell.com/]结果: 5352 得到[http://www.pythonav.com]结果: 3932

## 题外话： 如果你是windows10 + python3.8 + aiohttp3.6.2版本 使用asyncio.run(main())运行时候会报错： “RuntimeError: Event loop is closed” 该错误可能是aiohttp与python3.8的兼容性bug。

总结

异步编程的主要目的在于：通过一个线程利用其io等待时间达到用更少的资源去做更多的事的目的