python的异步编程

      这里的异步编程基于python3.4和python3.5

1、一些重要的概念理解

（1）循环消息队列：

          

异步IO采用消息循环的模式，重复“读取消息—处理消息”的过程

消息模型解决等待IO操作的问题： 
程序发出IO请求，直接结束本轮消息处理，进入下一轮消息的处理
当IO操作完成守，将收到一条IO完成的消息，处理该消息时获取IO操作的结果
在IO操作的这段时间里，异步模型可以循环处理其他操作，而且没有线程切换的消耗，同时处理多个IO请求，适用于大多数IO密集型的应用程序

总结; "异步IO模型"需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”这一过程。
（2）协程——coroutine
协程，又称微线程，纤程。英文名Coroutine。协程的概念很早就提出来了，但直到最近几年才在某些语言（如Lua）中得到广泛应用。子程序，或者称为函数，在所有语言中都是层级调用，比如A调用B，B在执行过程中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。
       协程调用与函数调用的区别：
       协程调用：但执行过程中，在子程序（即函数）内部可中断，然后转而执行别的子程序（另一个函数），在适当的时候再返回                          来接着执行。

                       协程针对的是一个线程中的函数调用之间，所以没有线程切换，是在一个线程中轮流执行和终端多个函数而已，所                          以效率较高，而且不需要锁机制（只有一个线程执行）

                       需要注意的是，子程序内部中断的不是函数调用，而是被调用函数中断（一般来说可能是一条执行命令需要很长时                          间等待结果返回，比如常见的IO操作），转而去执行另一个函数（不是调用另一个函数），类似两个函数轮流执                            行，没有发生函数调用。
       函数调用：程序执行中，函数调用是通过函数栈实现，因为栈FILO的特点，通常函数调用过程都是：A调用B，B在执行过程中                        又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。子程序（函数）调用总是一个入口，一次返                              回，调用顺序是明确的。而协程的调用和子程序不同
总结：协程的本质就是一个子程序，即一个使用async关键字定义的函数（在python3.4中使用的是@async.corontine修饰的函                数），它的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环，由事件循环调用
（3）、事件循环
      python异步IO的核心就在于事件循环，事件循环是一个无限的循环，程序开启一个无限的循环，程序员会把一些协程函数注册到事件循环上。当满足事件发生的时候，调用相应的协程函数。即协程函数不是自己调用的，而是通过“事件循环”去掉用的。
      操作如下：
      loop = asyncio.get_event_loop() #获取“事件循环”对象
loop.run_until_complete(hello()) #通过事件循环，去调用协程函数
loop.close()
（4）、任务task
协程对象就是一个原生可以挂起的函数，任务则是对协程进一步封装，其中包含任务的各种状态。即多个coroutine函数可以封装成一组Task然后并发执行，所谓task对象是Future类的子类。保存了协程运行后的状态，用于未来获取协程的结果。任务一般是有多个协程函数的时候，将他们绑定到一个任务组上，可以如下操作：

loop = asyncio.get_event_loop()
tasks = [hello(), hello1()，hello2（），hello3（）]  #多个协程函数绑定到一个任务上面，记住多个任务需要将任务写成                                                      列表的形式
loop.run_until_complete(asyncio.wait(tasks))         #当任务是列表的时候，必须使用asyncio.wait(t)的形式才行
loop.close()

实际上即使没有使用任务task，当传入一个协程，其内部会自动封装成task，如下：
loop.run_until_complete(hello())
#程序也会自动将hello封装成一个task任务，若函数有参数，一定要传入参数哦
下面是几种创建任务的方法：
方法1：通过loop.create_task()创建任务

t=[loop.create_task(number_sub(10))] #因为是列表的形式，所以下面必须要用asyncio.wait(t)作为参数，否则会报错
loop.run_until_complete(asyncio.wait(t))

loop.close()

与下面的等价

t=loop.create_task(number_sub(10)) #因为不是列表的形式，所以不需要asyncio.wait，而直接将t作为参数，否则会报错
loop.run_until_complete(t)

loop.close()

方法2：通过 asyncio.ensure_future()创建任务

t=[asyncio.ensure_future(number_sub(10))]

#因为是列表的形式，所以下面必须要用asyncio.wait(t)作为参数，否则会报错
loop.run_until_complete(asyncio.wait(t))

loop.close()

与下面等价

t=asyncio.ensure_future(number_sub(10))

#因为不是列表的形式，所以不需要asyncio.wait，而直接将t作为参数，否则会报错
loop.run_until_complete(t)

loop.close()

方法3：一次将多个协程函数绑定到同一个任务——要写成任务列表的形式

#t=[asyncio.ensure_future(number_sub(10)),asyncio.ensure_future(character_list())] #方法一

#t=[loop.create_task(number_sub(10)),loop.create_task(character_list())] #方法二

t=[number_sub(10),character_list()] #方法三，这三种方法都可以
loop.run_until_complete(asyncio.wait(t)) #但因为是列表形式，所以要用wait
loop.close()

与下面是等价的

t=asyncio.gather(asyncio.ensure_future(number_sub(5)), asyncio.ensure_future(character_list()))
print(t)
loop.run_until_complete(t) #通过asyncio的gather（）方法将多个协程函数连接起来，而没有写成列表形式，故而不需要wait（）
print(t)
loop.close()

task进一步了解：
task也是一个对象，我们还可以通过打印task，来来查看相关的一些状态信息，如下所示：

loop=asyncio.get_event_loop()
t=loop.create_task(number_sub(10))
print(t) #执行之前的状态
loop.run_until_complete(t)
print(t)
loop.close()

打印结果如下 ：

<Task pending coro=<number_sub() running at f:\�о������꼶��\Tensorflow���ѧϰ\TensorFlowBoardʵ��\asyncio_3.4.py:3>>
it's 10
it's 9
it's 8
it's 7
it's 6
it's 5
it's 4
it's 3
it's 2
it's 1
<Task finished coro=<number_sub() done, defined at f:\�о������꼶��\Tensorflow���ѧϰ\TensorFlowBoardʵ��\asyncio_3.4.py:3> result=None>

第一个表示执行之前的状态，然后执行出结果，第二个表示执行之后的状态。乱码是因为文件路径中出现了中文的缘故。
task是Future的子类。isinstance(task,
asyncio.Future)将会输出True。

下面是整个程序的代码：

import asyncio

@asyncio.coroutine #在python3.5里面，改为了async def number_sub(n):
def
number_sub(n):
while n>0:
print("it's
{0}".format(n))
yield from asyncio.sleep(1)
#asyncio.sleep()本身就是一个“异步协程函数” 当然这里可以是其他自定义的异步协程函数，
#这里仅仅是模拟一个耗时的异步过程
n-=1
#在python3.5里面，改为了await asyncio.sleep(1)

@asyncio.coroutine
#在python3.5里面，改为了async def number_sub(n):
def
character_list():
li=['a','b','c','d','e','f','g']
for i in li:
print("it's
{0}".format(i))
yield from asyncio.sleep(1)

#在python3.5里面，改为了await asyncio.sleep(1)

loop=asyncio.get_event_loop()
t=asyncio.gather(asyncio.ensure_future(number_sub(5)), asyncio.ensure_future(character_list()))
loop.run_until_complete(t)
loop.close()

在python3.5版本中，在语法层面在3.4的基础之上做了一些改进，即所谓的async——await语法。详情可以自己查阅相关的资料。