Python asyncio协程学习总结

该类不是线程安全的。

类法

• 取消()
  取消 future 并安排执行回调

  如果未来已完成或取消，则返回False。否则，将 future 的状态修改为已取消，安排执行回调，并返回True。

• 取消()

  如果未来已取消，

  返回 True。

• 完成（）
  如果 future 已完成，则返回 True。

  完成表示结果可用或发生异常，或未来已被取消。

• 结果()

  返回未来呈现的结果。

  如果未来已被取消，则会引发 CancelledError。如果未来的结果尚不可用，则会引发 InvalidStateError。如果 future 已经完成并且有异常，则会抛出该异常。

• 异常()
  返回未来设置的异常。

  仅当future完成时才返回异常（如果没有设置异常则返回None）。如果 future 被取消，则会引发 CancelledError。如果未来尚未完成，则会引发 InvalidStateError。

• add_done_callback(fn)

  添加回调以在 future 完成时运行。

  使用 future 对象作为参数调用回调。如果调用时 future 已完成，请使用 call_soon() 调用回调。

  使用 functools.partial 将参数传递给回调。例如

  fut.add_done_callback(functools.partial(print, "Future:",lush=True)) 将调用 print("Future:", fut,lush=True)

• remove_done_callback(fn)

​ 从“完成后调用”列表中删除回调的所有实例。

​ 返回已删除回调的数量。

• set_result(结果)
  将未来标记为已完成并设置其结果。

  如果调用此方法时 future 已完成，则会引发 InvalidStateError

• ​ set_exception(异常)

  将未来标记为已完成并设置例外。

  如果调用此方法时 future 已完成，则会引发 InvalidStateError。

示例：使用 Future 与 run_until_complete()

导入异步异步 def Slow_Operation（未来）：
等待 asyncio.sleep(1)
future.set_result('未来已经完成！')
循环 = asyncio.get_event_loop()
未来 = asyncio.Future()
asyncio.ensure_future(slow_operation(future))
循环.run_until_complete(未来)
print(future.result()) # Future 已经完成！
循环.close()

协程函数负责计算（耗时1秒）并在以后存储结果。 run_until_complete()方法等待future的完成。

注：
run_until_complete() 方法内部使用 add_done_callback() 方法在 future 完成时收到通知。

Future类封装了可调用对象的异步执行

示例：使用 Future 与 run_forever()

可以使用 Future.add_done_callback() 方法以不同的方式编写前面的示例，以明确描述控制流：

导入异步
异步 def Slow_Operation（未来）：
等待 asyncio.sleep(1)
future.set_result('未来已经完成！')
def 得到的结果（未来）：
打印（未来.结果（））
循环.stop()
循环 = asyncio.get_event_loop()
未来 = asyncio.Future()
asyncio.ensure_future(slow_operation(future))
future.add_done_callback(got_result)
尝试：循环运行_forever()
最后：
循环.close()

如果待处理任务被销毁，其封装的协程将无法完成。这可能是一个错误并记录警告：

任务已被销毁，但正在等待处理！
任务： wait_for=>

请勿直接创建 Task 实例：使用 ensure_future() 函数或 AbstractEventLoop.create _task( ) 方法。

该类不是线程安全的。

类法

• all_tasks（循环=无）
  返回给定事件循环的所有任务的集合。默认情况下，返回当前事件循环中的所有任务。

• current_task（循环=无）
  返回给定事件循环中当前正在运行的任务。默认返回当前事件循环中的当前任务。

  当未在任务上下文中调用此函数时，

  返回 None

• 取消()
  请求取消任务

  安排在事件循环的下一次迭代中将 CancelledError 抛出到封装的协程中。然后，协程有机会使用 try/ except/finally 来清理甚至拒绝请求。

  与Future.cancel()不同，这并不能保证任务将被取消：异常可能会被捕获并采取行动，从而延迟任务的取消或完全阻止任务的取消。该任务还可能返回一个值或引发不同的异常。

  调用此方法后，cancelled()不会立即返回True（除非任务已被取消）。当包装的协程因CancelledError异常终止时，任务将被标记为已取消（即使cancel()尚未被调用）。

• get_stack（*，限制=无）

  返回此任务协程的堆栈帧列表。

  如果协程未完成，则返回其暂停的堆栈。如果协程成功完成或被取消，则返回一个空列表。如果协程异常终止，则返回回溯帧列表。

  堆栈帧始终按从最旧到最新的顺序排列。

  可选 limit 给出返回的最大帧数；默认情况下，将返回所有可用的帧。它的含义根据是否返回堆栈或回溯而有所不同：返回堆栈的最新帧，但返回回溯的最旧帧（这与回溯模块的行为一致）。

  由于我们无法控制的原因，对于挂起的协程仅返回一个堆栈帧。

• print_stack（*，限制=无，文件=无）

  打印此任务协程的堆栈或回溯。

  为get_stack() 检索的帧生成类似于回溯模块的输出。 limit参数传递给get_stack()。 file参数是将输出写入的 I/O 流；默认情况下，输出写入 sys.stderr

示例：并行执行任务

并行执行 3 个任务（A、B、C）

导入异步
异步 def 阶乘（名称，数字）：
f=1
对于范围（2，数字+1）中的i：
print("任务 %s: 计算阶乘(%s)..." % (name, i))
等待 asyncio.sleep(1)
f*=i
print("任务 %s: 阶乘(%s) = %s" % (名称, 数字, f))
循环 = asyncio.get_event_loop()
循环.run_until_complete(asyncio.gather(
阶乘（“A”，2），
阶乘（“B”，3），
阶乘（“C”，4），
））
循环.close()

输出：

任务 B：计算阶乘 (2)...
任务 C：计算阶乘(2)...
任务 A：计算阶乘(2)...
任务 B：计算阶乘(3)...
任务 C：计算阶乘(3)...
任务 A：阶乘(2) = 2
任务 B：阶乘(3) = 6任务 C：计算阶乘(4)...
任务 C：阶乘(4) = 24

任务在创建时会自动调度执行。所有任务完成后，事件循环将停止。

任务功能

注：

在以下函数中，可选的循环参数允许显式设置底层任务或协程使用的事件循环对象。如果未提供，则使用默认事件循环

• www.sychzs.cn_completed（fs，*，循环=无，超时=无）

  在等待时返回一个 Future 实例的迭代器。

  如果在所有 Future 完成之前发生超时，则会引发 asyncio.TimeoutError。

  示例：

  对于 as_completed(fs) 中的 f：
  result = Yield from f # 'yield from' 可能会提高
  #使用结果
  

  注：
  未来的 f 不一定是 fs

  的成员

• asyncio.ensure_future（coro_or_future，*，循环=无）

  安排协程对象的执行：在其封装在Future中。返回一个Task对象。

  如果参数是Future，则直接返回。

  版本3.4.4中新增

  版本3.5.1变更: 函数接受任何可等待对象。

• asyncio.async(coro_or_future, *, loop=None)
  废弃的ensure_future()的别名

  版本 3.4.4开始废弃

• asyncio.wrap_future(future, *, loop=None)

  将concurrent.futures.Future对象封装在Future对象中。

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

  返回来自给定协程对象或future的future聚合结果。

  所有future必须共享相同的事件循环。如果所有task都成功完成，那么返回的future结果就是结果列表(按照原始序列的顺序，不一定是结果到达的顺序）。如果return_exceptions为true，则task中的异常将被视为成功的结果，并收集在结果列表中；否则，第一个抛出的异常将立即传递给返回的future。

  取消：如果外部Future被取消，则所有子项(尚未完成)也将被取消。如果任何子项被取消，这将被视为引发CancelledError错误——在这种情况下，外部Future不会被取消。（这是为了防止取消一个子项而导致其他子项被取消。）

• asyncio.iscoroutine(obj)
  如果obj是一个协程对象，该对象可能基于生成器或async def协程，则返回True。

• asyncio.iscoroutinefunction(func)
  如果func被判断为协程函数，则返回True，协程函数可以是被修饰的生成器函数或async def函数。

• www.sychzs.cn_coroutine_threadsafe(coro, loop)

  向给定的事件循环提交一个协程对象。

  返回concurrent.futures.Future以访问结果。

  该函数被从不同于运行事件循环线程的线程调用。用法：

  # Create a coroutine
  coro = asyncio.sleep(1, result=3)
  # Submit the coroutine to a given loop
  future = www.sychzs.cn_coroutine_threadsafe(coro, loop)
  # Wait for the result with an optional timeout argument
  assert future.result(timeout) == 3
  

  如果在协程中引发异常，则会通知返回的future。它还可以用于取消事件循环中的task：

  try:
  result = future.result(timeout)
  except asyncio.TimeoutError:
  print('The coroutine took too long, cancelling the task...')
  future.cancel()
  except Exception as exc:
  print('The coroutine raised an exception: {!r}'.format(exc))
  else:
  print('The coroutine returned: {!r}'.format(result))
  

  注意：
  与模块中的其他函数不同，run_coroutine_threadsafe() 要求显式传递loop参数。

  版本3.5.1中新增

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

  创建一个给定秒数后完成的协程--阻塞指定的秒数。sleep函数还可以指定result参数，协程完成时将该参数值返回给调用者（默认返回None）

• asyncio.shield(arg, *, loop=None)
  等待future，保护它不被取消。

  语句:

  res = yield from shield(something())
  

  等价于:

  res = yield from something()
  

  除非包含它的协程被取消，否则在something()中运行的任务不会被取消。从something()的视角来看，并没法生取消。但是它的调用者仍然被取消，所以yield from表达式仍然会引发CancelledError。注意：如果通过其他方式取消了something()，这仍然会取消shield()。

  如果你想完全忽略取消（cancellation,不推荐），你可以将shield()与try/except子句结合使用，如下所示:

  try:
  res = yield from shield(something())
  except CancelledError:
  res = None
  

• coroutine asyncio.wait(futures, *, loop=None, timeout=None, return_when=ALL_COMPLETED)

  等待futures序列参数给定的Future和协程对象执行完成。协程将被封装在task中。返回两个Future集：(done，pending)。

  • futures序列参数不能为空。

  • timeout参数可用于控制返回前等待的最大秒数。timeout可以是int或float类型。如果未指定timeout参数或参数值为空，则没有等待时间限制，即永不超时。

  • return_when指示此函数何时返回。它必须是concurrent.futures模块的以下常量之一：

    • FIRST_COMPLETED 当任何future完成或被取消时，函数将返回。
    • FIRST_EXCEPTION 当任何future因为引发异常而结束时，函数将返回。如果没有future引发异常，那么它相当于ALL_COMPLETED。
    • ALL_COMPLETED当所有future结束或被取消时，函数将返回。

  这个函数是一个协程。

  用法:

  done, pending = yield from asyncio.wait(fs)
  

  注意
  这不会引发asyncio.TimeoutError。pending集合中存放的是发生超时时未完成的future。

• coroutine asyncio.wait_for(fut, timeout, *, loop=None)

  等待单个future或协程对象完成直到发生超时(如果超时限制的话)。如果timeout为None，则一直等待直到future完成。

  协程将被封装在Task中。

  函数返回Future或协同程序的结果。当发生超时时，将取消task并抛出asyncio.TimeoutError。为了避免任务取消，请将其封装在shield()中。

  如果取消wait，那么future fut也将被取消。

  该函数为一个协程，用法：

  result = yield from asyncio.wait_for(fut, 60.0)
  

参考连接：

https://www.sychzs.cn/A/gGdXlLmmd4/