8-3-1python语法基础-并发编程-协程创建以及协程的详细解释
前言
先看这个文章:
python进程,线程,协程,对比,思考: https://www.cnblogs.com/andy0816/p/15590085.html
协程
进程和线程是计算机提供的,协程是程序员创造的,不存在于计算机中。
协程也可称为微线程,一种用户态的上下文切换技术(通过一个线程实现代码块间的相互切换执行)在一个线程中,遇到io等待时间,线程可以利用这个等待时间去做其他事情。
协程的实现方式
- 在Python中有多种方式可以实现协程
第一种方式:使用第三方模块greenlet(了解)
- greenlet,是一个第三方模块,用于实现协程代码(Gevent协程就是基于greenlet实现)
- greentlet是一个第三方模块,需要提前安装 pip3 install greenlet才能使用。
- 在Python3.4之前官方未提供协程的类库,一般大家都是使用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中也可以传递参数用于在切换执行时相互传递值。
第二种方法: yield和yield form关键字(了解)
- 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中引入的。
第三种方法:纯使用asyncio实现(了解)
- asyncio,在Python3.4中引入的模块用于编写协程代码。
- 在Python3.4之前官方未提供协程的类库,一般大家都是使用greenlet等其他来实现。
- 在Python3.4发布后官方正式支持协程,即:asyncio模块。
- Python3.8之后 @asyncio.coroutine 装饰器就会被移除,推荐使用async & awit 关键字实现协程代码。
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耗时操作自动切花的功能。
第四种方法:async和awiat关键字结合asyncio(必须掌握)
- async & awiat,在Python3.5中引入的两个关键字,结合asyncio模块可以更方便的编写协程代码。
- 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))
总结
- 关于协程有多种实现方式,
- 基于async & await关键字的协程可以实现异步编程,这也是目前python异步相关的主流技术。
- 目前主流使用是Python官方推荐的asyncio模块和async&await关键字的方式,
- 例如:在tonado、sanic、fastapi、django3 中均已支持。
- 这种方式是必须要掌握的,其他的都了解就行了,
深刻理解上面的代码
深刻理解1---->async关键字和协程函数,协程对象
协程函数:
- 函数前面加了一个async
- 协程函数,定义形式为 async def 的函数。
- 协程对象,调用 协程函数 所返回的对象。
注意,
- async_test函数由于加了关键字,已经是协程函数,直接调用会返回协程对象,并不会执行函数内的代码。
# 定义一个协程函数
async def func():
pass
# 调用协程函数,返回一个协程对象
result = func()
注意:调用协程函数时,函数内部代码不会执行,只是会返回一个协程对象。
深刻理解2---->await关键字
- await是一个只能在协程函数中使用的关键字,用于遇到IO操作时挂起 当前协程(任务),
- 当前协程(任务)挂起过程中 事件循环可以去执行其他的协程(任务),
- 当前协程IO处理完成时,可以再次切换回来执行await之后的代码。
注意:
-
await后面是一个可等待对象,如协程对象、协程任务,用于告诉even loop在此协程中需要等待后面的函数运行完成后才能继续,运行完成后返回结果。
-
协程函数调用时,前面不加await会显示以下内容
RuntimeWarning: coroutine ‘xxx’ was never awaited -
await要在协程函数里面,否则会显示以下内容
‘await’ outside function
深刻理解3---->asyncio模块和run
案例
import asyncio
import time
async def async_test(delay: int, content):
await asyncio.sleep(delay)
print(content)
async def main():
await async_test(1, "lady")
await async_test(2, "killer9")
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
asyncio.run(main())
print(f"end at {time.strftime('%X')}")
run
该函数用来运行最高层级的入口点,如下面的main函数,并返回main函数的执行结果。
run函数的源码:
def run(main, *, debug=False):
if events._get_running_loop() is not None:
raise RuntimeError(
"asyncio.run() cannot be called from a running event loop")
if not coroutines.iscoroutine(main):
raise ValueError("a coroutine was expected, got {!r}".format(main))
loop = events.new_event_loop()
try:
events.set_event_loop(loop)
loop.set_debug(debug)
return loop.run_until_complete(main)
finally:
try:
_cancel_all_tasks(loop)
loop.run_until_complete(loop.shutdown_asyncgens())
finally:
events.set_event_loop(None)
loop.close()
可以看到run进行了一些类型判断等,之后创建了event loop,并且把main放到了event loop中。
我前面写的代码的整个流程如下:
asyncio.run(main()),把main返回的协程对象放到了event loop,转为了协程任务,event loop发现当前有一个可执行任务,开始执行,执行到await async_test(1,“lady”)时发现有await,需要等待协程对象,执行完之后再执行await async_test(2,“killer9”),所以耗时3秒。
深刻理解4---->Task对象
- 协程任务:coroutine task,事件循环调度的最小单位,可由协程对象转化。
- Tasks用于并发调度协程,通过asyncio.create_task(协程对象)的方式创建Task对象,参数是传入协程对象
- 这样可以让协程加入事件循环中等待被调度执行。除了使用 asyncio.create_task() 函数以外,
- 还可以用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
- 本质上是将协程对象封装成task对象,并将协程立即加入事件循环,同时追踪协程的状态。
注意:asyncio: Task, create_task, ensure_future 都可以创建任务,该用哪个?
-
使用高层级的 asyncio.create_task() 函数来创建 Task 对象,也可用低层级的 loop.create_task() 或 ensure_future() 函数。不建议手动实例化 Task 对象。
-
上面是三种方式实现的协程异步,有什么区别?
从Python 3.7开始,为此目的添加了asyncio.create_task(coro)高级功能。
您应该使用它来代替从coroutimes创建任务的其他方法。但是,如果您需要从任意等待创建任务,您应该使用asyncio.ensure_future(obj)。 -
asyncio.create_task() 函数在 Python 3.7 中被加入。在 Python 3.7 之前,可以改用低层级的 asyncio.ensure_future() 函数。
案例
import asyncio
import time
async def async_test(delay:int,content):
await asyncio.sleep(delay)
print(content)
async def main():
task_lady = asyncio.create_task(async_test(1,"lady"))
task_killer = asyncio.create_task(async_test(2,"killer9"))
await task_killer
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
asyncio.run(main())
print(f"end at {time.strftime('%X')}")
结果如下:
start at 16:40:53
lady
killer9
end at 16:40:55
可以看到等待了2秒。
create_task代码如下
def create_task(coro):
loop = events.get_running_loop()
return loop.create_task(coro)
可以看到该函数获取了正在运行的even loop,生成了一个协程任务对象后返回。
我前面写的代码的整个流程如下:
asyncio.run(main())把main函数放到了event loop,转为了任务对象,此时even loop有一个任务可执行,执行过程中创建了async_test(1,“lady”)、async_test(2,“killer9”)两个任务,这两个任务并发执行。
由于博主知道task_killer 任务耗时最久,所以等待该任务完成后再结束即可。当你不知道时,可以await所有任务,此时任务依然是并行执行的,当然,如果你只await了耗时短的,那么其他任务没有完成就结束了,例如 await task_lady,此处读者可自行尝试。
结果如下:
start at 10:44:07
lady
3
end at 10:44:08
那么这里也有一个问题,如果创建很多任务,总不能一行一行的写await吧?接下来就看看如何并发等待
## 深刻理解5---->wait
并发执行协程函数等,返回done和pending状态的任务对象集合
import asyncio
import time
async def async_test(delay:int,content):
await asyncio.sleep(delay)
print(content)
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
asyncio.run(asyncio.wait([async_test(1,"lady"),async_test(2,"killer")]))
print(f"end at {time.strftime('%X')}")
结果如下:
start at 17:30:41
lady
killer
end at 17:30:43
可以看到等待了2秒。
wait原代码如下:
async def wait(fs, *, loop=None, timeout=None, return_when=ALL_COMPLETED):
if futures.isfuture(fs) or coroutines.iscoroutine(fs):
raise TypeError(f"expect a list of futures, not {type(fs).__name__}")
if not fs:
raise ValueError('Set of coroutines/Futures is empty.')
if return_when not in (FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED):
raise ValueError(f'Invalid return_when value: {return_when}')
if loop is None:
loop = events.get_event_loop()
fs = {ensure_future(f, loop=loop) for f in set(fs)}
return await _wait(fs, timeout, return_when, loop)
超时不会取消可等待对象、不会抛出异常asyncio.TimeoutError异常
深刻理解6---->wait_for
超时会取消可等待对象,会抛出异常,但是参数只接收一个coroutine
import asyncio
import time
async def async_test(delay:int,content):
await asyncio.sleep(delay)
print(content)
async def main():
try:
await asyncio.wait_for( async_test(2, "killer"),timeout=1)
except asyncio.TimeoutError:
print("任务超时...")
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
asyncio.run(main())
print(f"end at {time.strftime('%X')}")
结果如下:
start at 14:17:27
任务超时…
end at 14:17:28
可以看到超时后抛出异常了
wait_for代码如下:
async def wait_for(fut, timeout, *, loop=None):
if loop is None:
loop = events.get_event_loop()
if timeout is None:
return await fut
if timeout <= 0:
fut = ensure_future(fut, loop=loop)
if fut.done():
return fut.result()
fut.cancel()
raise futures.TimeoutError()
waiter = loop.create_future()
timeout_handle = loop.call_later(timeout, _release_waiter, waiter)
cb = functools.partial(_release_waiter, waiter)
fut = ensure_future(fut, loop=loop)
fut.add_done_callback(cb)
try:
try:
await waiter
except futures.CancelledError:
fut.remove_done_callback(cb)
fut.cancel()
raise
if fut.done():
return fut.result()
else:
fut.remove_done_callback(cb)
await _cancel_and_wait(fut, loop=loop)
raise futures.TimeoutError()
finally:
timeout_handle.cancel()
可以看到对timeout进行了判断,raise了TimeoutError异常
深刻理解7---->gather
接收的是列表,结果将是一个由所有返回值聚合而成的列表。结果值的顺序与 aws 中可等待对象的顺序一致。如果 return_exceptions 为 False (默认),所引发的首个异常会立即传播给等待 gather() 的任务。aws 序列中的其他可等待对象 不会被取消 并将继续运行。
import asyncio
import time
async def async_test(delay:int,content):
await asyncio.sleep(delay)
return content
async def exception_test(delay:int,content):
await asyncio.sleep(delay)
raise TimeoutError("超时")
return content
async def main():
result_list = await asyncio.gather(exception_test(1,"lady"),async_test(2, "killer"),return_exceptions=True)
return result_list
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
res = asyncio.run(main())
print(res)
print(f"end at {time.strftime('%X')}")
结果如下:
start at 15:16:10
[TimeoutError(‘超时’), ‘killer’]
end at 15:16:12
可以看到return_exceptions=True时,一个任务抛出异常,其他的任务还会执行。
深刻理解8---->事件循环get_event_loop(扩展)
这个很少用了,future我也没提,都比较底层,这里简单说两个
通过asyncio.get_event_loop()获取事件循环,常用函数:
create_task:创建任务
run_until_complete:运行任务,返回结果
import asyncio
import time
async def async_test(delay:int,content):
await asyncio.sleep(delay)
print(content)
return content
if __name__ == '__main__':
print(f"start at {time.strftime('%X')}")
event_loop = asyncio.get_event_loop()
tasks = [event_loop.create_task(async_test(1,"lady")),event_loop.create_task(async_test(2,"killer"))]
res = event_loop.run_until_complete(asyncio.wait(tasks))
print(res)
print(f"end at {time.strftime('%X')}")
结果如下:
start at 15:46:43
lady
killer
({<Task finished coro=<async_test() done, defined at E:/project_workspace/git_workspace/Script/coroutine_learn.py:3> result=‘lady’>, <Task finished coro=<async_test() done, defined at E:/project_workspace/git_workspace/Script/coroutine_learn.py:3> result=‘killer’>}, set())
end at 15:46:45
事件循环,可以把他当做是一个while循环,这个while循环在周期性的运行并执行一些任务,在特定条件下终止循环。
import asyncio
loop = asyncio.get_event_loop()
事件循环和协程对象
- 程序中,如果想要执行协程函数的内部代码,需要 事件循环 和 协程对象 配合才能实现,如:
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)
这个过程可以简单理解为:将协程当做任务添加到 事件循环 的任务列表,然后事件循环检测列表中的协程是否 已准备就绪(默认可理解为就绪状态),如果准备就绪则执行其内部代码。
异步上下文管理器
- 这个异步的上下文管理器还是比较有用的,平时在开发过程中 打开、处理、关闭 操作时,就可以用这种方式来处理。
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())
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的事件循环。
如何使用异步?
- 我要使用我自己的一个例子,
- 上代码:
import time
import asyncio
import aiohttp
import redis
import queue
import logging
logging.basicConfig(level=logging.INFO,
format=
# 日志的时间
'%(asctime)s'
# 日志级别名称 : 当前行号
' %(levelname)s [%(filename)s : %(lineno)d ]'
# 日志信息
' : %(message)s'
# 指定时间格式
, datefmt='[%Y/%m/%d %H:%M:%S]')
logging = logging.getLogger(__name__)
# 第一步,把数据取出来,在redis
conn = redis.Redis(host="127.0.0.1", port="6379")
# proxy_list = conn.hgetall("use_proxy")
# proxy_list = conn.hvals("use_proxy")
proxy_list = conn.hkeys("use_proxy")
# logging.info(proxy_list)
# 第二步,把数据存入队列
proxy_queue = queue.Queue()
for proxy in proxy_list:
proxy_queue.put(str(proxy, encoding="utf-8"))
queue_size = proxy_queue.qsize()
# logging.info(queue_size)
# logging.info(proxy_queue.get())
async def fetch(session):
while True:
try:
proxy = proxy_queue.get(block=False)
# print(proxy_queue.qsize())
except queue.Empty:
break
headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:34.0) Gecko/20100101 Firefox/34.0',
'Accept': '*/*',
'Connection': 'keep-alive',
'Accept-Language': 'zh-CN,zh;q=0.8'}
# 代理验证目标网站
url_http = "http://httpbin.org/ip"
url_https = "https://www.qq.com"
http_code = False
https_code = False
proxy = "http://{}".format(proxy)
# 第一个任务到这个地方遇到了阻塞,就会挂起,然后执行第二个任务,直到所有协程都执行起来,这个时候事件循环里面是有1个main协程,多个协程
try:
async with session.head(url_http, headers=headers, proxy=proxy, verify_ssl=False, timeout=10) as response:
res_http = response.status
if res_http == 200:
http_code = True
except Exception as e:
http_code = False
try:
async with session.get(url_https, headers=headers, proxy=proxy, verify_ssl=False, timeout=10) as response:
res_https = response.status
if res_https == 200:
https_code = True
except Exception as e:
https_code = False
if http_code and https_code:
logging.info("http_status:{} https_status:{} 代理:{} ".format(str(http_code).ljust(6),
str(https_code).ljust(6), proxy.ljust(25)))
async def main():
async with aiohttp.ClientSession() as session:
task_list = []
for i in range(20):
# t = asyncio.create_task(fetch(session))
# task_list.append(t)
# 上面两行,不要这么写,这么写就是同步的效果了,就不是异步的效果了
# # 这一步是创建task任务,并且都加入到事件循环中,里面是传入一个协程对象,
task_list.append(asyncio.create_task(fetch(session)))
for i in task_list:
# 这个await 是等待返回,一直要等待返回值之后,才会往下走,这个时候main协程是挂起的状态,
# 如果没有这个for循环,发现main函数结束了之后,hi协程并没有结束,整个的协程就结束了,
# 所以main是主的,其他是子的,主的结束了,子的不管有没有结束都会结束,
# 有点像是多线程里面的join,但是又不太一样,
await i
if __name__ == '__main__':
# 这个run,是创建事件循环,并且把main() 协程加入事件循环中,这个是一个主线程
asyncio.run(main())
协程总结:
- 协程(Coroutine),也可以被称为微线程,是一种用户态内的上下文切换技术。
- 其实就是通过一个线程实现代码块相互切换执行。
- 但是,协程来回切换执行的意义何在呢?协程牛逼的地方到底在哪里呢??
- 计算型的操作,利用协程来回切换执行,没有任何意义,来回切换并保存状态 反倒会降低性能。
- IO型的操作,利用协程在IO等待时间就去切换执行其他任务,当IO操作结束后再自动回调,
- 那么就会大大节省资源并提供性能,从而实现异步编程(不等待任务结束就可以去执行其他代码)。
总结
- 为了提升性能越来越多的框架都在向异步编程靠拢,目的就是用更少资源可以做处理更多的事
- 比如:FastAPI、Tornado、Sanic、Django 3、aiohttp等。
- 现在身边使用python的人,聊异步的也越来越多了,异步如何如何牛逼,性能如何吊炸天
- 水涨船高,别人会,你不会你就落后了,落后就要挨打