python -- 异步、asyncio

news2025/1/8 6:27:38

文章目录

协程
- 实现协成的方法
- - greenlet实现协程
  - yield 关键字
  - asyncio async & await（**重点**）
协程的意义
异步编程
- 事件循环
- 快速上手
- await
- Task对象
- asyncio.Future对象
- concurrent.futures.Future 对象

协程

协成不是操作系统提供的，是程序员人为创造的。

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

举个例子：

def func1():
    print(1)
    ...
    print(2)

def func2():
    print(3)
    ...
    print(4)

func1()
func2()

正常运行： 1 2 3 4
协程运行效果：1 3 2 4

实现协成的方法

greenlet，早期模块。
yield 关键字
asyncio 装饰器（python3.4）
async、await（python3.7）[推荐，主讲]

greenlet实现协程

pip install greenlet

在这里插入图片描述
运行结果： 1 3 2 4

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 4 2

asyncio async & await（重点）

遇到IO阻塞自动切换

import asyncio

async def func1():
    print(1)
    await asyncio.sleep(2)
    print(2)

async def func2():
    print(3)
    print(4)

tasks = [
    asyncio.ensure_future( func1() ),
    asyncio.ensure_future( func2() ),
]
loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

先尝试运行理解，后面详细讲解

协程的意义

在一个线程中如果遇到IO等待时间，线程不会傻傻等待，利用空闲时间再去干点其他事。

案例：去下载三张图片（网络IO）

普通三张图片（同步）

import requests

def download_img(url):
    print('开始下载：', url)
    # 发送请求
    response = requests.get(url)
    # 保存图片
    file_name = url.split('/')[-1]
    with open(file_name, mode='wb') as f:
        f.write(response.content)
        
if __name__ == '__main__':
    url_list = ['url1', 'url2', 'url3']
    for url in url_list:
        download_img(url)

结果：url1（下载，结束）–>url2（下载，结束）–>url3（下载，结束）

协程方式（异步）

import asyncio
import aiohttp

async def download_img(session, url):
    print('开始下载：', url)
    # 发送请求
    async with session.get(url, verify_ssl=False) as response:
        content = await response.content.read()
        # 保存图片
        file_name = url.split('/')[-1]
        with open(file_name, mode='wb') as f:
            f.write(content)

async def main():
    async with aiohttp.client() as session:
        url_list = ['url1', 'url2', 'url3']
        tasks = [asyncio.create_task(download_img(session, url)) for url in url_list]
        await asyncio.wait(tasks)

if __name__ == '__main__':
    asyncio.run(main())

结果：下载（url1, url2, url3） -同时下载->完成（url1, url2, url3）

协程是实现异步的一种方式！！！不是唯一方式。

异步编程

事件循环

理解成为一个死循环，去检测并执行某些代码。
在这里插入图片描述
以上描述的是以下代码：

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

快速上手

协程函数，定义函数时，async def 函数名
协程对象，执行协程函数()得到的协程对象。

async def func():
	pass
result = func()

注意：执行协程函数对象，函数内部代码不会执行。

async def func():
	print('执行我吧')
result = func()

loop = asyncio.get_event_loop()
loop.run_until_complete(result)

# 或者 python3.7以上
asyncio.run(result)

await

await + 可等待的对象（协程对象、Future、Task对象–>IO等待）

import asyncio


async def func():
	print('执行我吧')
	response = await asyncio.sleep(2)
	print('结束：', response)

result = func()
asyncio.run(result)

结果：

执行我吧
结束： None

await 就是等待对象得到结果之后再继续向下走

Task对象

在事件循环中，添加多个任务

示例1

# 示例1
import asyncio

async def func():
	print(1)
	response = await asyncio.sleep(2)
	print('2')
	return '结束func'

async def main():
	print('main开始')

	# 创建task对象
	task1 = asyncio.create_task(func())

	# 再次创建
	task2 = asyncio.create_task(func())

	print('main结束')

	re1 = await task1
	re2 = await task2
	print(re1, re2)

asyncio.run(main())

结果：

main开始
main结束
1
1
2
2
结束func 结束func

示例2:

# 示例2
import asyncio

async def func():
	print(1)
	response = await asyncio.sleep(2)
	print('2')
	return '结束func'

async def main():
	print('main开始')

	# 创建task对象
	task_list = [asyncio.create_task(func())]

	print('main结束')

	done,pending = await asyncio.wait(task_list, timeout=2) # 最多等2秒
	print(done) # 已完成集合
	print(pending) # 未完成集合

asyncio.run(main())

asyncio.Future对象

Task 继承 Future，Task 对象内部await 结果的处理基于Future对象来的。

示例1

import asyncio


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函数
	# fut.set_result('666')
	await loop.create_task(set_after(fut))

	# 等待Future对象获取最终结果，否则一直等待下去
	data = await fut
	print(data)

	# 等待任务最终结果（Future对象），没有结果则会一直等待下去
	await fut

asyncio.run(main())

concurrent.futures.Future 对象

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

import 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)
	return 1

# 创建线程池
pool = ThreadPoolExecutor(max_workers=5)

# 创建进程池
# pool = ThreadPoolExecutor(max_workers=5)

for i in range(10):
	fut = pool.submit(func, i)
	print(fut)