0
点赞
收藏
分享

微信扫一扫

Future与Task


​​Tasks and coroutines​​

翻译的python官方文档

这个问题的恶心之处在于,如果你要理解​​coroutine​​​,你应该理解​​future​​​和​​task​​​。而你如果想理解​​future​​​和​​task​​​你应该先理解​​coroutine​​。所以在第一遍阅读官方文档的时候,感觉完全是在梦游。但读到第二遍和第三遍的时候,就清楚很多了。

Coroutines

协程(​​coroutine​​)包括两个概念:

  1. 协程函数(​​async def​​​ 或者​​@asyncio.coroutine​​)
  2. 协程函数所返回的协程对象。

协程功能:

  1. 通过​​result = await future​​​或者​​result = yeild from future​​​,悬挂协程,直到​​future​​​完成,获取​​future​​​的结果/异常(参见下面对​​future​​​及​​future​​​结果的描述,或等看完​​future​​之后回来再阅读这一段)。
  2. 通过​​result = await coroutine​​​ 或者​​result = yeild from coroutine​​ 等待另一个协程的结果(或者异常,异常会被传播)。
  3. ​returen expression​​​ 返回该协程的结果,被​​await​​​,或者​​yield from​​获取。
  4. ​raise exception​​​,抛出异常,被​​await​​​,或者​​yield from​​获取。

调用协程函数并不能使该协程运行。调用协程函数所返回的协程对象,在被你安排执行之前,不会做任何事情。有两种方式可以启动它:

  1. 通过在一个已经启动的协程中调用:​​await coroutine​​​或者​​yield from coroutine​
  2. 或者通过​​ensure_task()​​​以及​​loop.create_task()​​安排协程的执行。

只有事件循环在运行的时候,协程才能运行


在本文档中,有些普通函数返回了一个future,也被标记为​coroutine​。这是故意的,这样以后就可以自由使用这些函数。如果是在回调代码中使用这个函数,用​ensure_future​包装他。


hello_world.py

import asyncio

# 创建一个协程
async def hello_world():
print("Hello World!")

loop = asyncio.get_event_loop()
# Blocking call which returns when the hello_world() coroutine is done
# 在事件循环中调用这个协程
# 不过这里只有一个协程,而其不阻塞
loop.run_until_complete(hello_world())
loop.close()

hello_world2.py

# 这段代码和上面的代码执行结果是相同的。只不过用了另一种调用协程的方式
# 先在loop.call_soon()中安排好,再通过loop.run_forever()调用
# 注意,这里在hello_world中,调用了loop.stop(),否则事件循环就不会终止。
import asyncio

def hello_world(loop):
print('Hello World')
loop.stop()

loop = asyncio.get_event_loop()

# Schedule a call to hello_world()
loop.call_soon(hello_world, loop)

# Blocking call interrupted by loop.stop()
loop.run_forever()
loop.close()

Future与Task_赋值


 注意这里​​return 1+2​​​,实际上是​​raise StopIteration(3)​​协程其实是在不停返回结果的。最后的结果才会被返回。

future

​future​​​是一个容器,或者占位符(placeholder),用于接受异步的结果。这里指的是​​asyncio.Future​​​而不是​​coroutines.futures.Future​​。

接口

​result()​

返回future的结果

​set_result()​

指示future已结束,并赋值。注意,必须显式地调用这个接口,才能给future赋值。


import asyncio

# 一个对future进行赋值的函数
async def slow_operation(future):
await asyncio.sleep(1)
# 给future赋值
future.set_result('Future is done!')

loop = asyncio.get_event_loop()
# 创建一个future
future1 = asyncio.Future()
# 使用ensure_future 创建Task
asyncio.ensure_future(slow_operation(future1))
future2 = asyncio.Future()
asyncio.ensure_future(slow_operation(future2))
# gather Tasks,并通过run_uniti_complete来启动、终止loop
loop.run_until_complete(asyncio.gather(future1, future2))
print(future1.result())
print(future2.result())
loop.close()

如果我们注释掉`future.set_result('Future is done!')一行,这个程序将永远不会结束。

TASK

将一个协程的执行过程安排好:用一个​​future​​​包装起来。​​Task​​​是​​Future​​的一个子类。

​Task​​​ 负责在实现循环中执行一个协程。 如果被包装的协程由一个​​future​​​产生,​​task​​​会暂停被包装协程的执行,等待​​future​​​的完成。当​​future​​​完成时,被包装协程会重启,当​​future​​结果/异常返回。

事件循环使用协同调度:事件循环每次只能执行1个操作。其他​​task​​​可以在别的线程的事件循环中执行。当​​task​​​等待​​future​​​完成时,事件循环会执行一个新的​​task​​。

取消​​task​​​与取消​​future​​​不同。调用​​cancel()​​​将会向被包装的协程抛出​​CacelledError​​​。如果被包装协程没有捕获​​CacelledError​​​或者抛出​​CancelledError​​​时, ​​cancelled()​​​才返回​​True​

太长了,我就不翻译了大意就是说,虽然​​task​​​的​​cancel()​​​函数,只会向被包装协程发出抛出一个异常,但是​​task​​​是否真的​​canceled​​取决于被包装协程如何处理这个异常。

不要直接创建​​task​​​实例,使用​​ensure_future()​​​函数或者​​loop.create_task()​​方法。

任务相关函数

​asyncio.ensure_future​

安排协程的执行。用future包装它,返回一个task。

​asyncio.gather(*coros_or_futures, loop=None, return_exceptions=False)​

将多个协程或future,集成为一个future。
所有的future必须在一个事件循环中。如果所有的future都成功完成了,则按照输入顺序(而不是返回顺序)返回所有result。

​asyncio.sleep(delay, result=None, *, loop=None)​

sleep函数,注意,是可以返回结果的



举报

相关推荐

0 条评论