协程
一个协程可以：
- result=await future 或者 result=yield from future——这两句将会挂起协程，直到future完成后再返回future的运行结果，或者抛出异常。
- result=await coroutine 或者 result=yield from coroutine——它将等待另一个协程产生结果，或者抛出异常
@asyncio.coroutine——标记基于生成器协程的装饰器，它允许生成器使用yield from来调用async def协程；也允许生成器被async def协程调用，比如使用await表达式。
调用协程后并不会马上执行代码，需要你调度执行。有两种方法可以让其开始运行：从其他协程中调用yield from coroutine 或 await coroutine；使用ensure_future()函数或者AbstractEventLoop.create_task()方法执行。
asyncio一些关键字的说明：
- event_loop事件循环：程序开启一个无限循环，把一些函数注册到事件循环上，当满足事件发生的时候，调用相应的协程函数。
- coroutine:协程对象，指一个使用async关键字定义或者@asyncio.coroutine装饰的函数，它的调用不会立刻执行函数，而是会返回一个协程对象。协程对象需注册到事件循环，由事件循环调用。
- task任务：一个协程对象是一个原生可挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。
- future：代表将来执行或没有执行的任务的结果。与task没有本质上的区别。
使用asyncio.sleep(1)和time.sleep(1)的区别是前者立即返回一个Future对象，下次循环时判断是否过2s，而不是阻塞等待。使用time.sleep()会导致并发效果作废。
@asyncio.coroutine
def hello():
print("Hello world!")
r=yield from asyncio.sleep(1)
print("Hello again!")
#这是一个coroutine对象，此时该函数并没有执行
coroutine=hello()
#获取eventloop
loop=asyncio.get_event_loop()
#将协程加入到事件循环loop中，执行coroutine
loop.run_until_complete(coroutine)
loop.close()
运行结果为：
整个流程就是：我们首先定义一个协程，然后创建一个事件循环，将协程注册到事件循环loop中，并且启动事件循环。
await关键字
await关键字用来对一些耗时的操作进行挂起，比如IO操作、网络请求等。协程遇到await后，事件循环会挂起该协程，然后执行下一个协程，直到其他的协程也执行或者挂起。
import asyncio
async def wget(host):
print('wget %s...' % host)
connect=asyncio.open_connection(host,80) #返回返回一个StreamReader和一个StramWriter的实例
#StreamReader是提供API向IO流写入数据的写入器对象
reader,writer=await connect
header='GET / HTTP/1.0\r\nHost:%s\r\n\r\n' %host #HTTP请求报文
writer.write(header.encode('utf-8'))
await writer.drain() #drain()函数是在事件循环中刷新缓存区，
#也就是把需要发送出去的数据从缓存区发出去
#特别在数据量大情况下保证数据完整性
while True:
line=await reader.readline()
if line==b'\r\n':
break
print('%s header > %s' %(host,line.decode('utf-8').rstrip()))
writer.close()
loop=asyncio.get_event_loop()
tasks=[wget(host) for host in ['www.sina.com.cn','www.sohu.com','www.163.com']]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
运行结果：
Task类和Future类
task类是Future类的子类，task负责协程在事件循环中的执行，如果已包装的协程yield from一个future，则task终止已包装协程的执行，等待future的完成。当future完成后，协程带着future执行的结果或异常重新开始执行。
事件循环使用协作调度：事件循环每次只能运行一个task。其他事件循环在不同线程运行时，其他的task就可以并行运行。当一个task等待future的完成时，事件循环会执行一个新的task。
task的取消不同于future的取消，调用cancel()将向协程抛出CancelledError异常。若已包装的协程没有捕捉到CancelledError异常，cancelled()将只返回True。
Task类是非线程安全的，我们介绍一个他的主要方法。
- all_tasks(loop=None):返回事件循环中的所有task。
- current_task(loop=None):返回事件循环中当前运行的task
- cancel():task取消，与Future.cancel()不同的是，它不保证task将会被取消。
task实例的创建
有两种方法创建Task实例，分别为ensure_future()函数或者AbstractEventLoop.create_task()方法。
ensure_future函数的定义如下，参数为coroutine或future对象，返回一个task对象。
asyncio.ensure_future(coro_or_future, *, loop=None)
@asyncio.coroutine
def hello():
print("Hello world!")
r=yield from asyncio.sleep(1)
print("Hello again!")
#这是一个coroutine对象，此时该函数并没有执行
coroutine=hello()
#获取eventloop
loop=asyncio.get_event_loop()
#创建task
#task=loop.create_task(coroutine)
task=asyncio.ensure_future(coroutine)
print(task)
#将协程加入到事件循环loop中，执行coroutine
loop.run_until_complete(task)
print(task)
loop.close()
运行结果为：
输出task我们可以看到，在协程执行前，task是处于pending状态，协程执行完毕后，task处于finished状态。我们也可以看到task对应的协程，这正是验证了task是对协程的进一步封装。
Task一些方法的使用
import asyncio
import time
now = lambda: time.time()
async def do_some_work(x):
print("waiting:",x)
await asyncio.sleep(x)
return "Done after {}s".format(x)
async def main():
coroutine1=do_some_work(1)
coroutine2=do_some_work(2)
coroutine3=do_some_work(8)
tasks=[
asyncio.ensure_future(coroutine1),
asyncio.ensure_future(coroutine2),
asyncio.ensure_future(coroutine3)
]
#dones,pending=await asyncio.wait(tasks)
#for task in dones:
# print("Task ret:",task.result())
results=await asyncio.gather(*tasks)
for result in results:
print("Task ret:",result)
start=now()
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
print("Time:", now()-start)
运行结果为：
coroutine asyncio.wait(futures, *, loop=None, timeout=None, return_when=ALL_COMPLETED)
wait()方法等待一组Future和coroutine对象的完成，其中coroutine对象将会包装成Task对象。该方法返回两组Future：（done，pending），分别表示以完成和未运行的Future。并且只有所有的future完成后才返回，所以当我们输出pending的长度时会发现其为0。
asyncio.gather(*coros_or_futures, loop=None, return_exceptions=False)
返回所给coroutine对象或future的结果。上述例子中我们获得一个list，遍历取得每个coroutine对象的结果。所有的futures必须共享一个event loop。当例子中的tasks取消后，则里面的三个coroutine对象都将取消，当其中的coroutine对象取消后不会影响tasks。
task的并行执行
前面提到，调用协程时并不会直接运行，而是需要调用run_until_complete()方法将协程注册到事件循环，这其实就是将协程包装成立一个task对象。它保存了协程运行后的状态
import asyncio
async def factorial(name,number):
f=1
for i in range(2,number+1):
print("Task %s: Compute factorial(%s)..."%(name,i))
await asyncio.sleep(5)
f*=i
print("Task %s:factorial(%s)=%s"%(name,number,f))
loop=asyncio.get_event_loop()
loop.run_until_complete(asyncio.gather(
factorial("A",2),
factorial("B",3),
factorial("C",4),
))
loop.close()
运行结果为：
绑定回调
import asyncio
async def slow_operation(future):
await asyncio.sleep(1)
future.set_result('Future is done!')
def got_result(future):
print(future.result())
loop.stop()
loop=asyncio.get_event_loop()
future=asyncio.Future()
coroutine=slow_operation(future)
task=asyncio.ensure_future(coroutine)
print(task)
task.add_done_callback(got_result)
print(task)
运行结果为：
使用add_done_callback()方法添加一个回调函数，当future也就是task执行完毕后，运行该回调函数，上述例子的回调函数中通过future获取执行的结果。
协程停止
future对象一共有四种状态：pending、running、done和canceled。
当刚创建对象时，其状态为pending，执行的时候为running，执行完毕后为done，还可以对task进行取消。
cancel()
当对task对象取消时，调用此方法。和Future.cancel()方法不同的是，它不保证task会被取消：异常可能会被捕捉并立刻反应、延迟取消或者不取消。当cancel()被调用后，canceled()方法不一定返回True，只有当coroutine因CancelledError异常而终止的时候返回True。
AbstractEventLoop.run_forever()
运行event loop
AbstractEventLoop.stop()
停止运行事件循环
AbstractEventLoop.is_closed()
当事件循环关闭时返回True
AbstractEventLoop.close()
关闭事件循环。循环将不能运行，挂起的回调将丢失。它将清除队列并且关闭执行器，但不会等待执行器完成。它是不可逆的，在此之后不应该调用其他方法。
Abstracteventloop.run_until_complete(future)
运行直到future对象运行完
参考：