Python中的异步IO和协程

Python中的异步IO和协程

Python中的协程是通过“生成器（generator）”的概念实现的。这里引用廖雪峰Python教程中的例子，并做一点修改和“装饰”：

def consumer():         # 定义消费者，由于有yeild关键词，此消费者为一个生成器
    print("[Consumer] Init Consumer ......")
    r = "init ok"       # 初始化返回结果，并在启动消费者时，返回给生产者
    while True:
        n = yield r     # 消费者通过yield接收生产者的消息，同时返给其结果
        print("[Consumer] conusme n = %s, r = %s" % (n, r))
        r = "consume %s OK" % n     # 消费者消费结果，下个循环返回给生产者

def produce(c):         # 定义生产者，此时的 c 为一个生成器
    print("[Producer] Init Producer ......")
    r = c.send(None)    # 启动消费者生成器，同时第一次接收返回结果
    print("[Producer] Start Consumer, return %s" % r)
    n = 0
    while n < 5:
        n += 1
        print("[Producer] While, Producing %s ......" % n)
        r = c.send(n)   # 向消费者发送消息并准备接收结果。此时会切换到消费者执行
        print("[Producer] Consumer return: %s" % r)
    c.close()           # 关闭消费者生成器
    print("[Producer] Close Producer ......")

produce(consumer())输出结果：[Producer] Init Producer ......
[Consumer] Init Consumer ......
[Producer] Start Consumer, return init ok
[Producer] While, Producing 1 ......
[Consumer] conusme n = 1, r = init ok
[Producer] Consumer return: consume 1 OK
[Producer] While, Producing 2 ......
[Consumer] conusme n = 2, r = consume 1 OK
[Producer] Consumer return: consume 2 OK
[Producer] While, Producing 3 ......
[Consumer] conusme n = 3, r = consume 2 OK
[Producer] Consumer return: consume 3 OK
[Producer] While, Producing 4 ......
[Consumer] conusme n = 4, r = consume 3 OK
[Producer] Consumer return: consume 4 OK
[Producer] While, Producing 5 ......
[Consumer] conusme n = 5, r = consume 4 OK
[Producer] Consumer return: consume 5 OK
[Producer] Close Producer ......

代码中添加了很详细的print语句和注释，帮助大家更好的理解。这里删除了源代码consumer中的“return”语句。如果还是不太明白，可以在编辑器中进行debug调试，一步步跟踪程序的运行过程。

关于异步IO，在Python3.4中可以使用asyncio标准库。该标准库支持一个时间循环模型（EventLoop），我们声明协程，然后将其加入到EventLoop中，即可实现异步IO。

Python中也有一个关于异步IO的很经典的HelloWorld程序（同样参考于廖雪峰教程）：

# 异步IO例子：适配Python3.4，使用asyncio库
@asyncio.coroutine
def hello(index):                   # 通过装饰器asyncio.coroutine定义协程
    print('Hello world! index=%s, thread=%s' % (index, threading.currentThread()))
    yield from asyncio.sleep(1)     # 模拟IO任务
    print('Hello again! index=%s, thread=%s' % (index, threading.currentThread()))

loop = asyncio.get_event_loop()     # 得到一个事件循环模型
tasks = [hello(1), hello(2)]        # 初始化任务列表
loop.run_until_complete(asyncio.wait(tasks))    # 执行任务
loop.close()                        # 关闭事件循环列表

同样这里的代码添加了注释，并增加了index参数。输出currentThread的目的是演示当前程序都是在一个线程中执行的。返回结果如下：

Hello world! index=1, thread=<_MainThread(MainThread, started 14816)>
Hello world! index=2, thread=<_MainThread(MainThread, started 14816)>
Hello again! index=1, thread=<_MainThread(MainThread, started 14816)>
Hello again! index=2, thread=<_MainThread(MainThread, started 14816)>

在Python3.5中引入了关于异步IO的新语法：async和await关键字。

# 异步IO例子：适配Python3.5，使用async和await关键字
async def hello(index):       # 通过关键字async定义协程
    print('Hello world! index=%s, thread=%s' % (index, threading.currentThread()))
    await asyncio.sleep(1)     # 模拟IO任务
    print('Hello again! index=%s, thread=%s' % (index, threading.currentThread()))

loop = asyncio.get_event_loop()     # 得到一个事件循环模型
tasks = [hello(1), hello(2)]        # 初始化任务列表
loop.run_until_complete(asyncio.wait(tasks))    # 执行任务
loop.close()                        # 关闭事件循环列表

从代码中可以看出，使用async代替@asyncio.coroutine，使用await代替yield from，使得协程代码更加简洁易懂。

在爬虫中使用协程实现异步IO

异步IO特别适合爬虫的工作，因为爬虫中所有的请求都属于IO密集型任务，想得到比较好的爬虫效率，使用协程很重要。关于Http异步请求，建议使用 aiohttp库 ，一个异步的HTTP客户端/服务器框架。这里举个例子，更多用法可以参考其官方文档。

async def get(url):
	async with aiohttp.ClientSession() as session:
		async with session.get(url) as resp:
		print(url, resp.status)
		print(url, await resp.text())

loop = asyncio.get_event_loop()     # 得到一个事件循环模型
tasks = [                           # 初始化任务列表
    get("http://zhushou.360.cn/detail/index/soft_id/3283370"),
    get("http://zhushou.360.cn/detail/index/soft_id/3264775"),
    get("http://zhushou.360.cn/detail/index/soft_id/705490")
]
loop.run_until_complete(asyncio.wait(tasks))    # 执行任务
loop.close()                        # 关闭事件循环列表