python 协程 & 异步 & asyncio

协程

协程在计算机中不是真实存在的，是由程序员人为创造的

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

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

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


fun1()
fun2()

协程能够实现程序在fun1() 和 fun2() 函数之间 交叉运行。

协程详细说明

协程是一种支持非阻塞并发的编程模式，它可以在执行过程中暂停和恢复，从而允许程序在等待某些操作完成时执行其他任务。通过协程，可以实现高效的并发和异步编程，可以有效地利用计算资源，提高程序的性能和响应能力。

协程的主要特点如下：

非阻塞式并发：协程允许程序在执行过程中主动挂起和恢复，而不会阻塞其他任务的执行。这意味着可以在等待某些操作完成时，切换到执行其他任务，从而实现并发处理。

显式挂起和恢复：协程通过特定的语法和关键字来实现挂起和恢复的操作。在Python中，可使用await关键字来暂停协程的执行，并等待某个异步操作完成后恢复执行。

协作式调度：协程需要通过协作式调度来实现切换任务的机制。调度器可以根据一定的策略在协程之间切换执行，通常是在协程主动挂起时进行切换。

共享状态：协程可以共享状态，因为它们在同一个线程中执行。这意味着可以通过共享变量来实现协程间的通信和同步。

协程可以用于处理诸如网络请求、文件读写、数据库操作等耗时的任务。通过使用协程，可以充分利用等待操作的时间来执行其他任务，从而提高程序的效率。

在Python中，asyncio模块提供了对协程的支持，使用async/await关键字来定义协程函数，并提供了一套事件循环和相关工具来调度和管理协程的执行。

需要注意的是，协程并不是线程，它是在单个线程中执行，并利用事件循环来切换协程的执行。这使得协程具有很高的效率和可扩展性，但也需要谨慎处理共享状态和阻塞操作，以避免协程的执行被阻塞或出现竞争条件。

协程在python中的四种实现方式

• greenlet, 早期模块。
• yield关键字。
• asyncio装饰器 （py3.4)。
• async、await关键字 （py3.5) 【推荐】。

1. greenlet
   greenlet 是第三方模块，使用之前需要安装模块

pip3 install greenlet

示例代码：

from greenlet import greerflet

def func1():
	print (1)	＃第2步：输出 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 函数

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

3. asynico
   在python3.4及以后的版本。

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.coroutine 装饰器装饰的函数为协程函数 ，协程函数必须放在asyncio.get_event_loop () 创建的事件循环中。
注意：通过asyncio创建的协程会在遇到IO耗时时会自动切换事件循环中的其他任务。

4. async、await关键字

import asyncio

async def func10):
	print (1)	＃ 网络I0请求：下载一张图片
	await asyncio.sleep(2)	＃ 遇到I0耗时操作，自动化切换到tasks中的其他任务
	print (2)
	
async def func20:
	print (3)	＃ 网络Io请求：下载一张图片
	await asyncio.sleep(2） # 遇到I0耗时操作，自动化切换到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等待时间，线程不会阻塞，利用空闲时间去处理其他事情。

例如：通过图片链接下载三张图片，传统的同步代码在下载的时候会等待前一个图片下载完毕才启动下一张图片的下载。而使用协程下载时当启动了第一张图片的下载后不会一直等到下载完成才去下载第二张而是发起第二张、第三种图片的下载，这种方式就是传说中的基于协程的异步编程。
伪代码如下：

import aiohttp
import asynico

async def down_img(session, url):
	print("发送请求: ", url)
	async with session.get(url) as response:
		content = await response.content.read()
		with open(file_name, mode='wb') as f:
			f.write(content)
		print('下载完成:' ,url)

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

if __name__ == 'main'
	async.run( main() )
	

异步编程

事件循环

可以理解为一个死循环，去检测并执行某些代码。

＃ 伪代码
任务列表 =〔任务1，任务2，任务了，……〕

while True :
	可执行的任务列表，已完成的任务列表 二去任务列表中检查所有的任务，将’可执行’和’已完成"的任务返回
	
	for 就绪任务 in 已准备就绪的任务列表：
		执行已就绪的任务
	
	for 已完成的任务 in 已完成的任务列表：
		在任务列表中移除 已完成的任务
	
	如果 任务列表 中的任务都已完成，则终止循环

# 去生成或获取一个事件循环
loop = asyncio.get_event_loop ()
# 将任务放到 ’任务列表‘
loop. run_until_complete(任务)

快速上手

协程函数，定义函数的时候 async def 函数名。
协程对象，执行 协程函数（） 得到的协程对象。

import asyncio

# 协程函数
async def func():
	pass

# 协程对象
result = func()

注意：执行协程函数创建协程对象，函数内部代码不会执行。如果想要运行协程函数内部代码，必须要将协程对象交给事件循环来处理。

import asyncio

# 协程函数
async def func():
	pass

# 协程对象
result = func()

# loop = asyncio.get_event_loop ()
# loop. run_until_complete(result )
asyncio.run( result )	# python3.7 后的写法，等同于上面两行代码。

await 关键字

从字面上来讲，a 表示 async ，wait 表示等待，表示等待执行。

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

示列1：

import asyncio

async def func():
	print("开始")
	response = await asyncio.sleep(2)
	print("结束"，response)

asyncio.run( func() )

当执行asyncio.run( func() ) 会先打印 ”开始“ 当遇到函数中含有 await 关键字的代码，如果在事件循环中有其他未完成的任务则会切换到其他任务，直到IO阻塞结束，才会执行 "结束”。

import asyncio

async def others():
	print ("start")		# 2 执行协程函数内部代码
	await asyncio.sleep (2)
	print('end')	# 3 协程函数内部代码执行结束
	return '返回值'	
	
async def func() :
	print("执行协程函数内部代码")	# 1 进入主线程
	＃ 遇到I0操作挂起当前协程（任务），等IO操作完成之后再继续往下执行。当前协程挂起时，事件可以去执行其他协程（任务）。
	response = await others()
	print("Io请求结東，结果为：", response)	# 4 Io请求结東，结果为：'返回值'
	
asyncio.run( func() )

通过示列2 可以看出协程与协程之间可以嵌套调用。

示列3 ：

import asyncio


async def others():
    print("start")  
    await asyncio.sleep(2)
    print('end')  
    return '返回值'


async def func():
    print("执行协程函数内部代码")  

    response1 = await others()
    print("Io请求结東，结果1为：", response1)  

    response2 = await others()
    print("Io请求结東，结果2为：", response2)  

asyncio.run(func())

执行协程函数内部代码
start
end
Io请求结東，结果1为： 返回值
start
end
Io请求结東，结果2为： 返回值

Process finished with exit code 0

通过示列3 可以知道一个协程函数里面可以有多个await。并且在单个协程函数里面的多个await是串行的，直到上一个await 有返回值之后才会执行下一个await。

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对象是一个抽象的概念，表示一个异步任务的执行状态。它通常与一个协程对象相关联，以便在协程执行时对其进行管理和控制。task对象有以下官方解释：

1. Task对象是一个Future对象的子类，它表示一个异步操作的执行状态。
2. Task对象具有额外的状态和方法，用于管理和控制协程的执行和取消操作。
3. Task对象可以从协程中创建，也可以在运行时动态创建。
4. Task对象可以被等待（await）以等待异步操作完成，并返回其结果或引发异常。
5. Task对象可以取消，以停止其关联的协程和异步操作的执行。
6. Task对象可以附加回调函数，在异步操作完成时自动运行。

示列1：

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "返回值，"


async def main():
    print("main开始")
    # 创建Task对象，将当前执行func函数任务添加到事件循环。
    task1 = asyncio.create_task(func())
    # 创建Task对象，将当前执行func函数任务添加到事件循环。
    task2 = asyncio.create_task(func())
    print("main结束")
    # 当执行某协程遇到IO操作时，会自动化切换执行其他任务。
    # 此处的await是等待相对应的协程全都执行完毕井获取结果
    ret1 = await task1
    ret2 = await task2
    print(ret1, ret2)


asyncio.run(main())

main开始
main结束
1
1
2
2
返回值， 返回值，

Process finished with exit code 0

示列2：

上面的示列1 是比较初级的写法，有助于理解协程的执行，在开发中经常用下面的写法

import asyncio


async def func():
    print(1)
    await asyncio.sleep(2)
    print(2)
    return "返回值，"


async def main():
    print("main开始")
    
    task_list = [
		asyncio.create_task(func(), name='t1'),
		asyncio.create_task(func(), name='t2')
	]
	
    print("main结束")
   
    done,pending = await asyncio.wait(task_list, timeout=None)
    print(done, pending )


asyncio.run(main())

main开始
main结束
1
1
2
2
{
    
    <Task finished name='t1' coro=<func() done, defined at E:\Project\PyCharmProject\Test\test\ts.py:4> result='返回值，'>, <Task finished name='t2' coro=<func() done, defined at E:\Project\PyCharmProject\Test\test\ts.py:4> result='返回值，'>} set()

Process finished with exit code 0

示列3：
除了示列2，还有一种方式可以创建task对象，这种方式作为了解即可。

import asyncio

async def func() :
	print(1)
	await asyncio.sleep (2)
	print (2)
	return "返回值"

task_list = [
	func(), 	# 注意这个地方的格式是函数名＋（）,因为此时还没有事件循环。
	func(),
]
done, pending = asyncio.run( asyncio.wait(task_list) )
print (done)

Future 对象

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

Task继承Future, Task 对象内部await结果的处理基于Future对象，在Future对象内部有一个 _state 变量 记录了 Task 对象的状态，通过_state的状态 实现await 的功能。

示列1：

async def main):
	# 获取当前事件循环
	1oop = asyncio.get_running_1oop0
	# 创建一个任务(Future对象），这个任务什么都不干。
	fut = loop. create_future ()
	# 等待任务最终结果 (Future对象），没有结果则会一直等下去。
	await fut
	
asyncio.run( main() )

由于fut 这个Future对象没有任何结果，所以执行当前程序会一直夯住。这个示列主要展示 await 后面 也可以跟 Future对象。

示列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函数，西数内部在25之后，会给fut赋值。
	# 即手动设置future任务的最终结果，那么fut就可以结東了。
	await loop.create_task(set_after (fut))
	# 等待 Future对象获取 最终结果，否则一直等下去
	data = await fut
	print (data)

asyncio.run( main() )

在示列2 中，Future对象 由于设置了 值，所以在执行到await fut 时 不会一直等待。当我们使用task 对象时，底层的Future 会自动将协程函数返回的值 set_result ，达到和上面同样的效果。

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 123
	
# 创建线程池
pool = ThreadPoolexecutor (max_workers=5)

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

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

我们知道当我们使用 async 这种协程的编码 所使用到的第三方模块 必须支持协程，假如存在第三方模块不支持异步的情况就可以使用 线程池、进程池中的concurrent.futures.Future对象 实现异步。

import time
import asyncio
import concurrent.rutures

def func1 ():
	# 某个耗时操作
	time.sleep (2)
	return "耗时操作"
	
asvnc 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 rut
	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:
	# wilh 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):
	#发送网络请求，下载图片（遇到网络下载图片的工0请求，自动化切换到其他任务)
	print（"开始下载："，ur1)
	loop = asyncio.get_event_1oop()
	#requests模块默认不支持异步操作，所以就使用线程池来配合实现了。
	future = loop.run_in_executor(None, requests.get, url)
	response = await future
	print('下载完成'）
	＃ 图片保存到本地文件
	file_name = url.rsplit('_')[-1]
	with open (file_name, mode='w') as file_object:
		file_object.write(response.content)
	
if __name_ == '_ main_ ':
	url_list =[
	"https://www3.autoimg.cn/newsdfs/g26/M02/35/A9/120×90_0_autohomecar__ChsEel2AXQ6A00H_AAFOCMS
	8nzu621.jpg'
	"https://www2.autoimg.cn/newsdfs/g30/M01/3C/E2/120×90_0_autohomecar_chccsv2BBICAUntfAADjJFd
	6800429.jpg',
	'https://www.autoimg.cn/newsdfs/g26/MOB/3C/65/120×90_0_autohomecar__ChcCP12BFCmAI083AAGq7vK
	OsGY193.jpg'
	]
	tasks = [ download_image(url) for url in url_list]
	
	loop = asyncio.get_event_loop()
	loop.run_until_complete( asyncio.wait(tasks) )