一、异步编程相关概念
1、I/O模型
- IO操作实际过程涉及到内核和调用这个IO操作的进程。对于一次IO访问（以read举例），数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说，当一个read操作发生时，它会经历两个阶段：
- 等待数据准备 (Waiting for the data to be ready)
- 将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)
- 正式因为这两个阶段，linux系统产生了下面五种网络模式的方案：
- 阻塞 I/O（blocking IO）
- 非阻塞 I/O（nonblocking IO）
- I/O 多路复用（ IO multiplexing）
- 信号驱动 I/O（ signal driven IO）
- 异步 I/O（asynchronous IO）
- 阻塞I/O：当用户进程调用了recvfrom这个系统调用，kernel就开始了IO的第一个阶段：准备数据（对于网络IO来说，很多时候数据在一开始还没有到达）。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。而在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。所以，blocking
IO的特点就是在IO执行的两个阶段都被block了。当进程进入阻塞状态，是不占用CPU资源的。 - 非阻塞I/O：当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。从用户进程角度讲
，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system
call，那么它马上就将数据拷贝到了用户内存，然后返回。所以，nonblocking
IO的特点是用户进程需要不断的主动询问kernel数据好了没有。 - I/O 多路复用：IO multiplexing就是我们说的select，poll，epoll，有些地方也称这种IO方式为event
driven
IO。select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。当用户进程调用了select，那么整个进程会被block，而同时，kernel会“监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。所以，I/O
多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入读就绪状态，select()函数就可以返回。 - 信号驱动 I/O：等待数据就绪阶段不阻塞，数据就绪后内核给进程发信号，复制数据阶段阻塞。
- 异步I/O：用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous
read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。也就是说异步
I/O两个阶段都不阻塞。
手动切换的,因此更加灵活,因此又叫用户空间线程。由于协程是用户调度的，所以不会出现执行一半的代码片段被强制中断了，因此无需原子操作锁。简单来说，协程是一种允许在特定位置暂停或恢复的子程序。协程适用于IO密集型的任务。
5、异步编程
- 回调：回调函数可以理解为是IO事件完毕后执行提前注册的回调函数。把I/O事件的等待和监听任务交给了操作系统，操作系统在知道I/O状态发生改变后，通过回调通知调用程序。
- 事件循环：事件循环 “是一种等待程序分配事件或消息的编程架构”。基本上来说事件循环就是，“当A发生时，执行B”。事件循环提供一种循环机制，让你可以“在A发生时，执行B”。基本上来说事件循环就是监听当有什么发生时，同时事件循环也关心这件事并执行相应的代码。事件循环被认为是一种循环是因为它不停地收集事件并通过循环来查找如何应对这些事件。对Python 来说，用来提供事件循环的 asyncio 被加入标准库中。asyncio重点解决网络服务中的问题，事件循环在这里将来自socket的 I/O已经准备好读和/或写作为“当A发生时”（通过selectors模块）。
- 异步编程：异步编程是一种IO模型，异步IO模型需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”这一过程。不论什么编程语言，但凡要做异步编程，事件循环+回调这种模式是逃不掉的，尽管它可能用的不是epoll，也可能不是while循环。但是由于基于回调的异步模型会出现回调地狱、错误处理困难、堆栈撕裂等问题，所以Python在事件循环+回调的基础上衍生出了基于协程的解决方案。
- 在Python中协程和事件循环一起使用构成了异步编程。Python 3.4 以后通过标准库 asyncio获得了事件循环的特性（主要通过selectors模块来实现）。
二、Python异步编程进化史
1、生成器yield
- 协程是为非抢占式多任务产生子程序的计算机程序组件，协程允许不同入口点在不同位置暂停或开始执行程序。从技术的角度来说，“协程就是你可以暂停执行的函数”。是不是和生成器的特性很像？
- 生成器第一次在PEP 255中提出（那时也把它成为迭代器，因为它实现了迭代器协议）。生成器允许创建一个在计算下一个值时不会浪费内存空间的迭代器。让函数遇到yield表达式时暂停执行，并且能够在后面重新执行，这对于减少内存使用、生成无限序列非常有用。
- 为了支持用生成器做简单的协程，Python 2.5 对生成器进行了增强(PEP 342)。有了PEP 342的加持，生成器可以通过yield暂停执行和向外返回数据，也可以通过send()向生成器内发送数据，还可以通过throw()向生成器内抛出异常以便随时终止生成器的运行。
yield关键字产生的协程是如何运行的，如下图：
- 从上图可以看出，调用生成器函数时，并不会立即执行函数，而是返回一个生成器对象，然后通过next()函数触发生成器，函数执行到yield表达式时会暂停，并将yield后面的值返回给触发者，通过send()函数将值从外部传入到生成器内部，生成器继续执行，直到遇到下一个yield表达式，当生成器函数所有的代码执行完没有遇到下一个yield，就会抛出异常，如果对生成器使用for循环，for循环会自动处理异常。
- 其实next()和send()在一定意义上作用是相似的，区别是send()可以传递yield表达式的值进去，而next()不能传递特定的值，只能传递None进去。因此，我们可以看做c.next()和 c.send(None) 作用是一样的。因此也可以不通过next()函数，通过send(None)来触发生成器，使用send()触发第一次传入的参数必须是None，否则会报错，因为第一次触发没有yield语句来接收其他非None的值。
- send(msg)和next()都会有返回值，返回值是下一个yield表达式的参数，比如说yield 5 则返回5。另外，在一个生成器中，如果没有 return，则默认执行至函数完毕，如果在执行过程中 return，则直接抛出 StopIteration 终止迭代。
2、yield from
Python3.3版本的PEP 380中添加了yield from语法。允许一个generator生成器将其部分操作委派给另一个生成器。其产生的主要动力在于使生成器能够很容易分为多个拥有send和throw方法的子生成器，像一个大函数可以分为多个子函数一样简单。Python的生成器是协程coroutine的一种形式，但它的局限性在于只能向它的直接调用者yield值。这意味着那些包含yield的代码不能想其他代码那样被分离出来放到一个单独的函数中。这也正是yield from要解决的。
yield from 后面需要加的是可迭代对象，它可以是普通的可迭代对象，也可以是迭代器，甚至是生成器。
虽然yield from主要设计用来向子生成器委派操作任务，但yield from可以向任意的迭代器委派操作。
2.1、替代for循环
- 对于简单的迭代器，yield from iterable本质上等于for item in iterable: yield item的缩写版：
#使用yield语句>>>defgen():...for cin'AB':...yield c...for iinrange(1,3):...yield i...>>>list(gen())['A','B',1,2]>>>#使用yield from实现相同的功能>>>defgen():...yieldfrom'AB'...yieldfromrange(1,3)...>>>list(gen())['A','B',1,2]2.2、打开双通道
- 先明确几个概念：
- 调用方：调用委派生成器的客户端（调用方）代码
- 委托生成器：包含yield from表达式的生成器函数
- 子生成器：yield from后面加的生成器函数
- 但是yield from不仅仅如此，还有更加强大的功能，不同于普通的循环，yield from允许子生成器直接从调用者接收其发送的信息或者抛出调用时遇到的异常，并且返回给委派生产器一个值。
- 代码如下：
from collectionsimport namedtuple
Result= namedtuple('Result','count average')# the subgeneratordefaverager():
total=0.0
count=0
average=NonewhileTrue:
term=yieldif termisNone:break
total+= term
count+=1
average= total/ countreturn Result(count, average)# the delegating generatordefgrouper(results, key):whileTrue:#只有当生成器averager()结束，才会返回结果给results赋值
results[key]=yieldfrom averager()defmain(data):
results={}for key, valuesin data.items():
group= grouper(results, key)next(group)for valuein values:
group.send(value)
group.send(None)
report(results)#如果不使用yield from，仅仅通过yield实现相同的效果，如下：defmain2(data):for key, valuesin data.items():
aver= averager()next(aver)for valuein values:
aver.send(value)try:#通过异常接受返回的数据
aver.send(None)except Exceptionas e:
result= e.valueprint(result)defreport(results):for key, resultinsorted(results.items()):
group, unit= key.split(';')print('{:2} {:5} averaging {:.2f}{}'.format(result.count, group, result.average, unit))
data={'girls;kg':[40.9,38.5,44.3,42.2,45.2,41.7,44.5,38.0,40.6,44.5],'girls;m':[1.6,1.51,1.4,1.3,1.41,1.39,1.33,1.46,1.45,1.43],'boys;kg':[39.0,40.8,43.2,40.8,43.1,38.6,41.4,40.6,36.3],'boys;m':[1.38,1.5,1.32,1.25,1.37,1.48,1.25,1.49,1.46],}if __name__=='__main__':
main(data)
总结如下：
- 迭代器（即可指子生成器）产生的值直接返还给调用者
- 任何使用send()方法发给委派生产器（即外部生产器）的值被直接传递给迭代器。如果send值是None，则调用迭代器next()方法；如果不为None，则调用迭代器的send()方法。如果对迭代器的调用产生StopIteration异常，委派生产器恢复继续执行yield from后面的语句；若迭代器产生其他任何异常，则都传递给委派生产器。
- 除了GeneratorExit 异常外的其他抛给委派生产器的异常，将会被传递到迭代器的throw()方法。如果迭代器throw()调用产生了StopIteration异常，委派生产器恢复并继续执行，其他异常则传递给委派生产器。
- 如果GeneratorExit异常被抛给委派生产器，或者委派生产器的close()方法被调用，如果迭代器有close()的话也将被调用。如果close()调用产生异常，异常将传递给委派生产器。否则，委派生产器将抛出GeneratorExit 异常。
- 当迭代器结束并抛出异常时，yield from表达式的值是其StopIteration 异常中的第一个参数。
- .一个生成器中的return expr语句将会从生成器退出并抛出 StopIteration(expr)异常。
3、asyncio框架
- 用yieldfrom改进基于生成器的协程，代码抽象程度更高。至此，Python已经具备异步编程的基础能力，于是Python语言开发者们充分利用yield from，在Python 3.4 试验性引入的异步I/O框架asyncio（PEP 3156），提供了基于协程做异步I/O编写单线程并发代码的基础设施。
- Python 3.4中，asyncio.coroutine修饰器用来标记作为协程的函数，这里的协程是和asyncio及其事件循环一起使用的。这赋予了Python第一个对于协程的明确定义：实现了PEP 342添加到生成器中的这一方法的对象，并通过collections.abc.Coroutine这一抽象基类表征的对象。这意味着突然之间所有实现了协程接口的生成器，即便它们并不是要以协程方式应用，都符合这一定义。为了修正这一点，asyncio要求所有要用作协程的生成器必须由asyncio.coroutine修饰。
- 有了对协程明确的定义（能够匹配生成器所提供的API），你可以对任何asyncio.Future对象使用 yield from，从而将其传递给事件循环，暂停协程的执行来等待某些事情的发生（ future 对象并不重要，只是asyncio细节的实现）。一旦future 对象获取了事件循环，它会一直在那里监听，直到完成它需要做的一切。当 future 完成自己的任务之后，事件循环会察觉到，暂停并等待在那里的协程会通过send()方法获取future对象的返回值并开始继续执行。
- 在 Python 3.4 中，用于异步编程并被标记为协程的函数看起来是这样的：
mport asyncio# Borrowed from http://curio.readthedocs.org/en/latest/tutorial.html.@asyncio.coroutinedefcountdown(number, n):while n>0:print('T-minus', n,'({})'.format(number))yieldfrom asyncio.sleep(1)
n-=1
loop= asyncio.get_event_loop()
tasks=[
asyncio.ensure_future(countdown("A",2)),
asyncio.ensure_future(countdown("B",3))]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()虽然发展到 Python 3.4 时有了yield from的加持让协程更容易了，但是由于协程在Python中发展的历史包袱所致，迭代器的过度重载，使用生成器实现协程功能有很多缺点：
- 协程与常规的生成器在相同语法时用以混淆，尤其是对心开发者而言。
- 一个函数是否是协程需要通过是否主体代码中使用了yield或者yield from语句进行检测，这样在重构代码中添加、去除过程中容易出现不明显的错误
- 异步调用的支持被yield支持的语法先定了，导致我们无法使用更多的语法特性，比如with和for语句。
于是根据Python 3.5 Beta期间的反馈，进行了重新设计：明确的把协程从生成器里独立出来—原生协程现在拥有了自己完整的独立类型，而不再是一种新的生成器类型。
4、async/await 原生协程
- Python设计者们在 3.5 中新增了async/await语法（PEP 492），将协程作为原生Python语言特性，并且将他们与生成器明确的区分开。它避免了生成器/协程中间的混淆，方便编写出不依赖于特定库的协程代码，称之为原生协程。async/await 和 yield from这两种风格的协程底层复用共同的实现，而且相互兼容。在Python 3.6 中asyncio库“转正”，不再是实验性质的，成为标准库的正式一员。
- Python 3.5 添加了types.coroutine修饰器，也可以像 asyncio.coroutine 一样将生成器标记为协程。你可以用 async def 来定义一个协程函数，虽然这个函数不能包含任何形式的 yield 语句；只有 return 和 await 可以从协程中返回值。
- 下面的新语法用于声明原生协程：
asyncdefread_data(db):pass协程的主要属性包括：
async def函数始终为协程，即使它不包含await表达式。
如果在async函数中使用yield或者yield from表达式会产生SyntaxError错误。
在内部，引入了两个新的代码对象标记：
- CO_COROUTINE用于标记原生协程（和新语法一起定义）
- CO_ITERABLE_COROUTINE用于标记基于生成器的协程，兼容原生协程。(通过types.coroutine()函数设置)
常规生成器在调用时会返回一个genertor对象，同理，协程在调用时会返回一个coroutine对象。
协程不再抛出StopIteration异常，而是替代为RuntimeError。常规生成器实现类似的行为需要进行引入future(PEP-3156)
当协程进行垃圾回收时，一个从未被await的协程会抛出RuntimeWarning异常
types.coroutine()：在types模块中新添加了一个函数coroutine(fn)用于asyncio中基于生成器的协程与本PEP中引入的原生携协程互通。使用它，“生成器实现的协程”和“原生协程”之间可以进行互操作。
这个函数将生成器函数对象设CO_ITERABLE_COROUTINE标记，将返回对象变为coroutine对象。如果fn不是一个生成器函数，那么它会对其进行封装。如果它返回一个生成器，那么它会封装一个awaitable代理对象。
注意：CO_COROUTINE标记不能通过types.coroutine()进行设置，这就可以将新语法定义的原生协程与基于生成器的协程进行区分。
await与yield from相似，await关键字的行为类似标记了一个断点，挂起协程的执行直到其他awaitable对象完成并返回结果数据。它复用了yield from的实现，并且添加了额外的验证参数。await只接受以下之一的awaitable对象：
- 一个原生协程函数返回的原生协程对象。
- 一个使用types.coroutine()修饰器的函数返回的基于生成器的协程对象。
- 一个包含返回迭代器的await方法的对象。
协程链：协程的一个关键特性是它们可以组成协程链，就像函数调用链一样，一个协程对象是awaitable的，因此其他协程可以await另一个协程对象。
任意一个yield from链都会以一个yield结束，这是Future实现的基本机制。因此，协程在内部中是一种特殊的生成器。每个await最终会被await调用链条上的某个yield语句挂起。
关于基于生成器的协程和async定义的原生协程之间的差异，关键点是只有基于生成器的协程可以真正的暂停执行并强制性返回给事件循环。所以每个await最终会被await调用链条上的某个由types.coroutine()装饰的包含yield语句的协程函数挂起。
为了启用协程的这一特点，一个新的魔术方法__await__被添加进来。在asyncio中，对于对象在await语句启用Future对象只需要添加await = iter这行到asyncio.Future类中。带有await方法的对象也叫做Future-like对象。
另外还新增了异步上下文管理 async with 和异步迭代器 async for。异步生成器和异步推导式都让迭代变得并发，他们所做的只是提供同步对应的外观，但是有问题的循环能够放弃对事件循环的控制，以便运行其他协程。
关于何时以及如何能够和不能使用async / await，有一套严格的规则：
- 使用async关键字创建一个协程函数，里面包含await或者return，调用协程函数，必须使用await获得函数返回结果。
- 在async异步函数中使用yield并不常见，这会创建一个异步生成器，可以使用async for来迭代异步生成器。
- 在async异步函数中使用yield from会抛出语法错误。同样在普通函数中使用await也是语法错误。
5、将 async/await 看做异步编程的 API
- Python的核心开发者David指出：async/await 实际上是异步编程的 API，人们不应该将async/await等同于asyncio，而应该将asyncio看作是一个利用async/await API 进行异步编程的框架。async/await 的设计意图就是为了让其足够灵活从而不需要依赖asyncio或者仅仅是为了适应这一框架而扭曲关键的设计决策。
- 下面是将async/await 看做异步编程的 API的一个完整的异步编程的例子，包括事件循环，三个countdown()协程函数并发运行：
import datetimeimport heapqimport typesimport timeclassTask:"""相当于asyncio.Task，存储协程和要执行的时间"""def__init__(self, wait_until, coro):
self.coro= coro
self.waiting_until= wait_untildef__eq__(self, other):return self.waiting_until== other.waiting_untildef__lt__(self, other):return self.waiting_until< other.waiting_untilclassSleepingLoop:"""一个事件循环，每次执行最先需要执行的协程，时间没到就阻塞等待，相当于asyncio中的事件循环"""def__init__(self,*coros):
self._new= coros
self._waiting=[]defrun_until_complete(self):# 启动所有的协程for coroin self._new:print(coro)
wait_for= coro.send(None)
heapq.heappush(self._waiting, Task(wait_for, coro))# 保持运行，直到没有其他事情要做while self._waiting:
now= datetime.datetime.now()# 每次取出最先执行的协程
task= heapq.heappop(self._waiting)if now< task.waiting_until:# 阻塞等待指定的休眠时间
delta= task.waiting_until- now
time.sleep(delta.total_seconds())print(task.coro, delta.total_seconds())
now= datetime.datetime.now()try:# 恢复不需要等待的协程
wait_until= task.coro.send(now)
heapq.heappush(self._waiting, Task(wait_until, task.coro))except StopIteration:# 捕捉协程结束的抛出异常pass@types.coroutinedefsleep(seconds):"""暂停一个协程指定时间，可把他当做asyncio.sleep()"""
now= datetime.datetime.now()
wait_until= now+ datetime.timedelta(seconds=seconds)
actual=yield wait_untilreturn actual- nowasyncdefcountdown(label, length,*, delay=0):"""协程函数，实现具体的任务"""print(label,'waiting', delay,'seconds before starting countdown')
delta=await sleep(delay)print(label,'starting after waiting', delta)while length:print(label,'T-minus', length)
waited=await sleep(1)
length-=1print(label,'lift-off!')defmain():"""启动事件循环，运行三个协程"""
loop= SleepingLoop(countdown('A',5), countdown('B',3, delay=2),
countdown('C',4, delay=1))
start= datetime.datetime.now()
loop.run_until_complete()print('Total elapsed time is', datetime.datetime.now()- start)if __name__=='__main__':
main()6、总结Python异步编程版本细节
- Python 2.5：增强生成器yield。
- Python 3.3：引入yield from表达式。
- Python 3.4：asyncio作为具有临时API的状态引入Python标准库中。
- Python 3.5：async和await成为Python语法的一部分，用于表示和协程，但它们还不是保留关键字。
- Python 3.6：引入异步生成器和异步推导式，asyncio的API被宣布为稳定版本而非临时。
- Python 3.7：async和await成为保留关键字，它们旨在替换asyncio.coroutine()装饰器。 asyncio.run()被引入asyncio包，简化协程运行，其中还包括许多其他功能。
三、asyncio工作原理
- 前面提到异步编程是通过事件循环+回调这种模式实现的，但是这种模式会出现回调地狱、错误处理困难、堆栈撕裂等问题，所以Python在事件循环+回调的基础上衍生出了基于协程的解决方案，并不是没有回调，而是巧妙的通过Future对象将回调隐藏其中，方便使用和理解。
- asyncio框架中有三个主要组件：协程对象、事件循环和Future&Task对象。
协程对象
协程对象：指一个使用async关键字定义的异步函数，是需要执行的任务，它的调用不会立即执行函数，而是会返回一个协程对象。协程不能直接运行，协程对象需要注册到事件循环，由事件循环调用。
有两种方法可以从协程读取异步函数的输出：
- 第一种方法是使用await关键字，这只能在异步函数中使用，等待协程终止并返回结果。
- 第二种方法是将协程添加到事件循环中。
在Python中编写异步函数时要记住的一件事是，在def之前使用了async关键字并不意味着你的异步函数将同时运行。如果采用普通函数并在其前面添加async，则事件循环将运行函数而不会中断，因为你没有指定允许循环中断你的函数以运行另一个协同程序的位置。指定允许事件循环中断运行的位置非常简单，每次使用关键字await等待事件循环都可以停止运行你的函数并切换到运行另一个注册到循环的协同程序。
事件循环
- 事件循环是执行我们的异步代码并决定如何在异步函数之间切换的对象。如果某个协程在等待某些资源，我们需要暂停它的执行，在事件循环中注册这个事件，以便当事件发生的时候，能再次唤醒该协程的执行。
- 运行异步函数我们首先需要创建一个协程，然后创建future或task对象，将它们添加到事件循环中，到目前为止，我们的异步函数中没有任何代码被执行过，只有调用loop.run_until_completed启动事件循环，才会开始执行future或task对象，loop.run_until_completed会阻塞程序直到所有的协程对象都执行完毕。
- 流程如下图：
- 事件循环是在线程中执行
- 从队列中取得任务
- 每个任务在协程中执行下一步动作
- 如果在一个协程中调用另一个协程（await ），会触发上下文切换，挂起当前协程，并保存现场环境（变量，状态），然后载入被调用协程
- 如果协程的执行到阻塞部分（阻塞I/O，Sleep），当前协程会挂起，并将控制权返回到线程的消息循环中，然后消息循环继续从队列中执行下一个任务．．．以此类推
- 队列中的所有任务执行完毕后，消息循环返回第一个任务
Future & Task对象
Future对象
- Future对象：Future对象封装了一个未来会被计算的可调用的异步执行对象，他们能被放入队列，他们的状态、结果或者异常能被查询。Future对象有一个result属性，用于存放未来的执行结果。还有个set_result()方法，是用于设置result的，并且会在给result绑定值以后运行事先给Future对象添加的回调。回调是通过Future对象的add_done_callback()方法添加的。
- 重要的是Future对象不能被我们创建，只能被异步框架创建，有两种方法：
# 该函数在 Python 3.7 中被加入，更加高层次的函数，返回Task对象
future1= asyncio.create_task(my_coroutine)# 在Python 3.7 之前，是更加低级的函数，返回Future对象或者Task对象
future2= asyncio.ensure_future(my_coroutine)第一种方法在循环中添加一个协程并返回一个task对象，task对象是future的子类型。第二种方法非常相似，当传入协程对象时返回一个Task对象，唯一的区别是它也可以接受Future对象或Task对象，在这种情况下它不会做任何事情并且返回Future对象或者Task对象不变。
Future对象有几个状态：
- Pending：就绪
- Running：运行
- Done：完成
- Cancelled：取消
创建Future对象的时候，状态为pending，事件循环调用执行的时候就是running，调用完毕就是done，如果需要取消Future对象的调度执行，可调用Future对象的cancel()函数。
除此之外，Future对象还有下面一些常用的方法：
- result()：立即返回Future对象运行结果或者抛出执行时的异常，没有timeout参数，如果Future没有完成，不会阻塞等待结果，而是直接抛出InvalidStateError异常。最好的方式是通过await获取运行结果，await会自动等待Future完成返回结果，也不会阻塞事件循环，因为在asyncio中，await被用来将控制权返回给事件循环。
- done()：非阻塞的返回Future对象是否成功取消或者运行结束或被设置异常，而不是查看future是否已经执行完成。
- cancelled()：判断Future对象是否被取消。
- add_done_callback()：传入一个可回调对象，当Future对象done时被调用。
- exception()：获取Future对象中的异常信息，只有当Future对象done时才会返回。
- get_loop()：获取当前Future对象绑定的事件循环。
需要注意的是，当在协程内部引发未处理的异常时，它不会像正常的同步编程那样破坏我们的程序，相反，它存储在future内部，如果在程序退出之前没有处理异常，则会出现以下错误：
Task exception was never retrieved- 有两种方法可以解决此问题，在访问future对象的结果时捕获异常或调用future对象的异常函数：
try:# 调用结果时捕获异常
my_promise.result()
catch Exception:pass# 获取在协程执行过程中抛出的异常
my_promise.exception()Task对象
- Task对象：Task对象是Future对象的子类型，coroutine和Future联系在一起。与 Future 不同的是它包含了一个将要执行的协程，从而组成一个需要被调度的任务，Task类用来管理协同程序运行的状态，负责在事件