Loading

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等待时间达到用更少的资源去做更多的事的目的

posted @ 2020-05-30 13:06  MrSu  阅读(1207)  评论(0)  编辑  收藏  举报