【Python学习之九】asyncio—异步IO

asyncio

　　这是python3.4引入的标准库，直接内置对异步IO的支持。asyncio的编程模型就是一个消息循环。从asyncio模块中直接获取一个EventLoop的引用，而后把须要执行的协程扔到EventLoop中执行，就实现了异步IO。

协程

　　子程序，或者称为函数。在全部语言中都是层级调用，好比A调用B，B在执行过程当中又调用了C，C执行完毕返回，B执行完毕返回，最后是A执行完毕。子程序调用是经过栈实现的，一个线程就是执行一个子程序。子程序调用老是一个入口，一次返回，调用顺序是明确的。而协程的调用和子程序不一样。

协程的定义

　　协程看上去是子程序，可是有很大的不一样。协程，执行过程当中，在内部可中断，而后转而执行别的程序，在适当的时候再返回来接着执行。在一个子程序中中断，去执行其余子程序，不是函数调用，有点相似CPU的中断。下面举个例子：

def A():
    print('1')
    print('2')
    print('3')

def B():
    print('x')
    print('y')
    print('z')

假设由协程执行，在执行A的过程当中，能够随时中断，去执行B，B也可能在执行过程当中中断再去执行A，结果多是：

1
2
x
y
3
z

可是在A中是没有调用B的，因此不是函数的调用中断。所以，协程的调用比函数调用理解起来要难一些。

协程的优点

　　协程最大的优点就是极高的执行效率。由于子程序切换不是线程切换，而是由程序自身控制，所以，没有线程切换的开销。第二大优点就是不须要多线程的锁机制，由于只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只须要判断状态就行了，因此执行效率比多线程高不少。

　　协程利用多个CPU的方法是，多进程+协程，既充分利用多核，又充分发挥协程的高效率，可得到极高的性能。

协程的实现

　　Python对协程的支持是经过generator（带有yield的函数）实现的。在generator中，咱们不但能够经过for循环来迭代，还能够不断调用next()函数获取由yield语句返回的下一个值。Python的yield不但能够返回一个值，它还能够接收调用者发出的参数。看个实例：

def consumer():
    r = 'k'  # 定义一个空字符串
    while True:  # 设定一个循环
        # 若是不调用consumer的send方法传入其参数给n，n将为None
        n = yield r
        if not n:  # 若是知足条件，表示方法外并未调用send
            return  # 执行return，退出方法，返回空值
        print('[CONSUMER] Consuming %s...' % n)
        r = '200 OK'


def produce(c):
    x = c.send(None)  # 启动生成器,至关于调用了next(c)
    print("This is qidong:", x)
    n = 0
    while n < 5:
        n = n + 1
        print('[PRODUCER] Producing %s...' % n)
        # 生产了东西，经过c.send(n)切换到consumer执行
        r = c.send(n)
        # consumer经过yield拿到消息，处理，又经过yield把结果传回
        print('[PRODUCER] Consumer return: %s' % r)
        # produce拿到consumer处理的结果，继续生产下一条消息
    # produce决定不生产了，经过c.close()关闭consumer，整个过程结束
    c.close()


c = consumer()
produce(c)

从实例能够看出来，整个生产者消费者的流程是无锁的，只由一个线程执行，produce和consumer协做完成任务，因此称为“协程”，而非线程的抢占式多任务。

asyncio实例

　　下面是用asyncio实现Hello world：

import asyncio


# @asyncio.coroutine把一个generator标记为coroutine（协程）类型
@asyncio.coroutine
def hello():
    print("Hello world!")
    # 异步调用asyncio.sleep(1):
    # yield from语法可让咱们方便地调用另外一个generator
    # asyncio.sleep()也是一个coroutine
    # 线程不会等待asyncio.sleep()，而是直接中断并执行下一个消息循环
    # 把asyncio.sleep(1)当作是一个耗时1秒的IO操做，在此期间，
    # 主线程并未等待，而是去执行EventLoop中其余能够执行的coroutine了，所以能够实现并发执行
    yield from asyncio.sleep(1)
    print("Hello again!")


# 从asyncio模块中直接获取EventLoop
loop = asyncio.get_event_loop()
# 执行coroutine
loop.run_until_complete(hello())
loop.close()

用Task封装两个coroutine试试：

import asyncio
import threading


@asyncio.coroutine
def hello():
    print('Hello world! (%s)' % threading.currentThread())
    yield from asyncio.sleep(1)
    print('Hello again! (%s)' % threading.currentThread())


# 从asyncio模块中直接获取EventLoop
loop = asyncio.get_event_loop()
tasks = [hello(), hello()]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

运行结果是：

Hello world! (<_MainThread(MainThread, started 7116)>)
Hello world! (<_MainThread(MainThread, started 7116)>)
Hello again! (<_MainThread(MainThread, started 7116)>)
Hello again! (<_MainThread(MainThread, started 7116)>)

能够看出来，两个协程是由同一个线程并发执行的。把asyncio.sleep()换成真正的IO操做，则多个coroutine就能够由一个线程并发执行。

asyncio网络实例

　　用asyncio的异步网络链接来获取sina、sohu和163的网站首页：

import asyncio


@asyncio.coroutine
def wget(host):
    print('wget %s...' % host)
    connect = asyncio.open_connection(host, 80)
    reader, writer = yield from connect
    header = 'GET / HTTP/1.0\r\nHost: %s\r\n\r\n' % host
    writer.write(header.encode('utf-8'))
    # drain()在事件循环中刷新缓冲区，特别是在数据量很大的状况下，保证数据完整性
    yield from writer.drain()
    while True:
        line = yield from reader.readline()
        if line == b'\r\n':
            break
        print('%s header > %s' % (host, line.decode('utf-8').rstrip()))
    # Ignore the body, close the socket
    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()

可见3个链接由一个线程经过coroutine并发完成。

总结　

　　asyncio模块提供了完善的异步IO支持。异步操做须要在coroutine（协程）中经过yield from完成。多个coroutine能够封装成一组Task而后并发执行。

　　注意在python3.5以后，能够把@asyncio.coroutine替换为async，yield from替换为await。使代码更简洁易懂。