Python的异步编程[0] -> 协程[1] -> 使用协程建立自己的异步非阻塞模型

使用协程建立自己的异步非阻塞模型

---

 

接下来例子中，将使用纯粹的Python编码搭建一个异步模型，相当于自己构建的一个asyncio模块，这也许能对asyncio模块底层实现的理解有更大的帮助。主要参考为文末的链接，以及自己的补充理解。

完整代码

#!/usr/bin/python
# =============================================================
# File Name: async_base.py
# Author: LI Ke
# Created Time: 1/29/2018 09:18:50
# =============================================================


import types
import time


@types.coroutine
def switch():
    print('Switch: Start')
    yield
    print('Switch: Done')

async def coro_1():
    print('C1: Start')
    await switch()
    print('C1: Stop')


async def coro_2():
    print('C2: Start')
    print('C2: 1')
    print('C2: 2')
    print('C2: 3')
    print('C2: Stop')

c_1 = coro_1()
c_2 = coro_2()

try:
    c_1.send(None)
except StopIteration:
    pass
try:
    c_2.send(None)
except StopIteration:
    pass
try:
    c_1.send(None)
except StopIteration:
    pass

print('--------------------------------')

def run(coros):
    coros = list(coros)

    while coros:
        # Duplicate list for iteration so we can remove from original list
        for coro in list(coros):
            try:
                coro.send(None)
            except StopIteration:
                coros.remove(coro)

c_1 = coro_1()
c_2 = coro_2()
run([c_1, c_2])

print('--------------------------------')

@types.coroutine
def action(t):
    trace=[]
    while True:
        trace.append(time.time())
        if trace[-1] - trace[0] > t:
            break # This break will end this function and raise a StopIteration
        yield

async def coro_1():
    print('C1: Start')
    await action(2)
    print('C1: Stop')


async def coro_2():
    print('C2: Start')
    await action(3)
    print('C2: Stop')

def timeit(f):
    def _wrapper(*args, **kwargs):
        start = time.time()
        re = f(*args, **kwargs)
        end = time.time()
        print('Time cost:', f.__name__, end-start)
        return re
    return _wrapper

c_1 = coro_1()
c_2 = coro_2()
timeit(run)([c_1])
timeit(run)([c_2])

print('--------------------------------')

c_1 = coro_1()
c_2 = coro_2()
timeit(run)([c_1, c_2])

分段解释

首先会导入需要的模块，这里仅仅使用types和time两个模块，放弃异步I/O的asyncio模块。

import types
import time

接下来定义一个switch函数，利用types.coroutine装饰器将switch装饰成一个协程，这个协程将完成一个切换功能。

@types.coroutine
def switch():
    print('Switch: Start')
    yield
    print('Switch: Done')

随后定义第一个协程，协程启动后，会进入一个await，即切入刚才的switch协程，这里使用async和await关键字完成对协程的定义。

async def coro_1():
    print('C1: Start')
    await switch()
    print('C1: Stop')

同样的，再定义第二个协程，第二个协程将从头到尾顺序执行。

async def coro_2():
    print('C2: Start')
    print('C2: 1')
    print('C2: 2')
    print('C2: 3')
    print('C2: Stop')

有了上面的两个协程，但我们在异步时，希望在执行完C_1的start后，切换进协程C_2，执行完成后再切换回来。那么此时就需要一个对协程切换进行控制的程序，具体顺序如下，

1. 启动协程c_1，启动后会切换进switch函数，
2. Switch中由于yield而切出，并保留上下文环境
3. c_1.send()将获得返回结果（如果有的话），并继续执行
4. 此时c_1已经被中止，启动c_2，则完成所有执行步骤，捕获生成器的中止异常
5. 这时c_2以执行完毕，再次切回c_1（此时会从switch yield之后开始执行）继续执行。

c_1 = coro_1()
c_2 = coro_2()

try:
    c_1.send(None)
except StopIteration:
    pass
try:
    c_2.send(None)
except StopIteration:
    pass
try:
    c_1.send(None)
except StopIteration:
    pass

最终得到结果如下，可以看到，整个过程完全按期望的流程进行，

C1: Start
Switch: Start
C2: Start
C2: 1
C2: 2
C2: 3
C2: Stop
Switch: Done
C1: Stop

但是这里的协程运行部分仍需改善，于是接下来便定义一个run函数用于执行一个协程列表。

run函数首先会遍历协程列表的副本，并不断尝试启动列表中的协程，当协程结束后便将协程从协程列表中删除，直到所有的协程都执行完毕为止。

def run(coros):
    coros = list(coros)

    while coros:
        # Duplicate list for iteration so we can remove from original list
        for coro in list(coros):
            try:
                coro.send(None)
            except StopIteration:
                coros.remove(coro)

c_1 = coro_1()
c_2 = coro_2()
run([c_1, c_2])

测试一下run函数，得到结果与前面相同，

C1: Start
Switch: Start
C2: Start
C2: 1
C2: 2
C2: 3
C2: Stop
Switch: Done
C1: Stop

到目前为止，完成了一个简单的异步模型的搭建，即c_2无需等待c_1执行完成再继续执行，而是由c_1交出了控制权进行协作完成，同时也不存在多线程的抢占式任务，因为由始至终都只有一个线程在运行，而且也没有混乱的回调函数存在。

但是，还存在一个阻塞问题没有解决，也就是说，如果c_1中的switch函数是一个耗时的I/O操作或其他阻塞型操作，则此时需要等待switch的阻塞操作完成才能交出控制权，可如果希望在等待这个耗时操作时，先去执行c_2的任务，再回来检测c_1中的耗时操作是否完成，则需要使用非阻塞的方式。

首先，对刚才的switch进行改造，完成一个action协程，这个协程会根据传入的参数，执行对应时间后，再退出协程引发StopIteration，实现方式如下，每次切换进action中都会记录下时间，然后将时间和第一次进入的时间进行对比，如果超过了设置的时间便退出，如果没超过限制时间，则切出协程交还出控制权。

@types.coroutine
def action(t):
    trace=[]
    while True:
        trace.append(time.time())
        if trace[-1] - trace[0] > t:
            break # This break will end this function and raise a StopIteration
        yield

接着定义两个协程，分别执行action时间为2秒和3秒，同时定义一个计算时间的装饰器，用于时间记录。

async def coro_1():
    print('C1: Start')
    await action(2)
    print('C1: Stop')


async def coro_2():
    print('C2: Start')
    await action(3)
    print('C2: Stop')

def timeit(f):
    def _wrapper(*args, **kwargs):
        start = time.time()
        re = f(*args, **kwargs)
        end = time.time()
        print('Time cost:', f.__name__, end-start)
        return re
    return _wrapper

然后我们先分别运行两个协程进行一个实验，

c_1 = coro_1()
c_2 = coro_2()
timeit(run)([c_1])
timeit(run)([c_2])

从输出的结果可以看到两个协程的耗时与action执行的时间基本相同，且顺序执行的时间为两者之和，

C1: Start
C1: Stop
Time cost: run 2.030202865600586
C2: Start
C2: Stop
Time cost: run 3.0653066635131836

接下来，利用异步非阻塞的方式来执行这两个协程，

c_1 = coro_1()
c_2 = coro_2()
timeit(run)([c_1, c_2])

最后得到结果

C1: Start
C2: Start
C1: Stop
C2: Stop
Time cost: run 3.0743072032928467

从结果中可以看到，此时的运行方式是异步的形式，c_1启动后由于进入一个耗时action，且action被我们设置为非阻塞形式，因此c_1交出了控制权，控制权回到run函数后，启动了c_2，而c_2同样也进入到action中，这时两个协程都在等待任务完成，而监视run则在两个协程中不停轮询，不断进入action中查看各自的action操作是否完成，当有协程完成后，将继续启动这个协程的后续操作，直到最终所有协程结束。

按照非阻塞异步协程的方式，可以以单线程运行，避免资源锁的建立，也消除了线程切换的开销，并且最终获得了类似多线程运行的时间性能。

 

相关阅读

---

1. 协程和 async / await

 

参考链接

---

http://www.oschina.net/translate/playing-around-with-await-async-in-python-3-5