[转载] Python协程从零开始到放弃

Python协程从零开始到放弃

Web安全 作者：美丽联合安全MLSRC 

 2017-10-09  3,973

 

Author: lightless@Meili-inc

Date: 20171009

0x00 前言

很久以前就听说Python的async/await很厉害，但是直到现在都没有用过，一直都在用多线程模型来解决各种问题。最近看到隔壁的Go又很火，所以决定花时间研究下Python协程相关的内容，终于在翻阅了一裤衩的资料之后有了一些理解。

0x01 起：一切从生成器开始

以往在Python开发中，如果需要进行并发编程，通常是使用多线程/多进程模型实现的。由于GIL的存在，多线程对于计算密集型的任务并不十分友好，而对于IO密集型任务，可以在等待IO的时候进行线程调度，让出GIL，实现『假并发』。

当然对于IO密集型的任务另外一种选择就是协程，协程其实是运行在单个线程中的，避免了多线程模型中的线程上下文切换，减少了很大的开销。为了理解协程、async/await、asyncio，我们要从最古老的生成器开始。

回顾Python的历史，生成器这个概念第一次被提出的时候是在PEP 255中被提出的，当时的Python版本为Python2.2。我们都知道range()函数，现在考虑一下我们来编写一个自己的range()函数，最直接最容易想到的方法也许是这样：

def my_range(max_number):
    sequence = []
    index = 0
    while index < max_number:
        sequence.append(index)
        index += 1
    return sequence

当你想创建一个很小的序列的时候，例如创建从0到100这样的列表，似乎没什么问题。但是如果想创建一个从0到999999999这么大的列表的话，就必须要创建一个完整的，长度是999999999的列表，这个行为非常占用内存。于是就有了生成器，用生成器来改写这个函数的话，会是下面这个样子：

def lazy_range(max_number):
    index = 0
    while index < max_number:
        yield index
        index += 1

当函数执行遇到yield的时候，会暂停执行。这样只需在内存中维护可以存储一个整数的内存空间就可以了。如果对生成器/迭代器不理解的话，可以参考Stack Overflow上的这篇高票回答：传送门

0x02 承：协程诞生

到这里可能还和协程没什么关系，但是实际上这已经是Python协程的雏形了，我们来看看维基上对于协程的定义：

Coroutines are computer program components that generalize subroutines for non-preemptive multitasking, by allowing multiple entry points for suspending and resuming execution at certain locations.

从某些角度来理解，协程其实就是一个可以暂停执行的函数，并且可以恢复继续执行。那么yield已经可以暂停执行了，如果在暂停后有办法把一些value发回到暂停执行的函数中，那么Python就有了『协程』。于是在PEP 342中，添加了“把东西发回已经暂停的生成器中”的方法，这个方法就是send()，并且在Python2.5中得到了实现。利用这个特性我们继续改写range()函数：

def smart_range(max_number):
    index = 0
    while index < max_number:
        jump = yield index
        if jump is None:
            jump = 1
        index += jump

就这样，整个生成器的部分似乎已经进入了stable的状态，但是在Python3.3中，这个情况发生了改变。在PEP 380中，为Python3.3添加了yield from，这个东西可以让你从迭代器中返回任何值（这里用的是迭代器，因为生成器也是一种迭代器），也可以让你重构生成器，我们来看这个例子：

def lazy_range(max_number):
    index = 0

    def gratuitous_refactor():
        while index < max_number:
            yield index
            index += 1
    yield from gratuitous_refactor()

这个特性也可以让生成器进行串联，使数据在多个生成器中进行传递。历史发展到这里，协程的出现似乎已经就差一步了，或者这里说是异步编程更恰当。在Python3.4中加入了asyncio库，使Python获得了事件循环的特性（关于事件循环的内容这里不再赘述）。asyncio + 生成器已经达到了异步编程的条件，在Python3.4中，我们就可以这样实现一个异步的模型：

import asyncio

@asyncio.coroutine
def counttdown(number, n):
    while n > 0:
        print("T-minus", n, "({})".format(number))
        yield from asyncio.sleep(1)
        n -= 1

loop = asyncio.get_event_loop()
tasks = [
    asyncio.ensure_future(counttdown("A", 2)),
    asyncio.ensure_future(counttdown("B", 5)),
]
loop.run_until_complete(asyncio.wait(tasks))
loop.close()

这里的asyncio.coroutine装饰器是用来标记这个函数是一个协程的，因为asyncio要求所有要用作协程的生成器必须由asyncio.coroutine装饰。在这段代码中，事件循环会启动两个countdown()协程，他们会一直执行，直到遇到了yield from asyncio.sleep()，会暂停执行，并且将一个asyncio.Future对象返回给事件循环。事件循环会监控这个asyncio.Future对象，一旦其执行完成后，将会把这个Future的执行结果返回给刚刚因为这个Future暂停的协程，并且继续执行原协程。

从这个具体的例子出发，抽象点来看，实际上这个过程变成了：

1. 你可以对任何asyncio.Future的对象进行yield from，将这个Future对象交给事件循环；
2. 暂停执行的协程将等待这个Future的完成；
3. 一旦Future获取到事件循环，并执行完所有的代码；
4. 事件循环感知到Future执行完毕，原暂停的协程会通过send()方法获取Future对象的返回值并且继续执行；

0x03 转：从yield from到await

终于到了最激动人心的地方，在Python3.5中，添加了types.coroutine装饰器以及async def和await。我们先来看一下Python3.4和Python3.5中如何定义一个协程函数：

# python34
@asyncio.coroutine
def py34_function():
    yield from work()

# python35
async def py35_function():
    await work()

看起来Python3.5中定义协程更为简单了，但是实际上生成器和协程之间的差别变的更加明显了。这里先要指出两个个注意点：

1. await只能用于async def的函数中；
2. yield from 不能用于async def的函数中；

除此之外，yield from和await可以接受的对象是略有区别的，await接受的对象必须是一个awaitable对象。什么是awaitable对象呢，就是一个实现了__await()__方法的对象，而且这个方法必须返回一个不是协程的迭代器。满足这两个条件，才算是一个awaitable对象，当然协程本身也是awaitable对象，因为collections.abc.Coroutine继承了collections.abc.Awaitable。换句话说，await后面可接受的对象有两种，分别是：协程和awaitable对象，当然协程也是awaitable对象。

在Python3.6中，这种特性继续被发扬光大，现在可以在同一个函数体内使用yield和await，而且除此之外，也可以在列表推导等地方使用async for或await语法。

result = [i async for i in aiter() if i % 2]
result = [await func() for fun in funcs if await condition()]

async def test(x, y):
    for i in range(y):
        yield i
        await asyncio.sleep(x)

0x04 合：尾声

到这里整个协程的历史已经是回顾完了，对于Python中的协程也有了一些理解，但是如何在实际中使用协程可能还有一些疑惑以及理解不够深刻的地方，准备继续研究几天，在下一篇文章讲一下实际场景中协程的运用和项目中遇到的问题。最后附上一些不错的文献：

How the heck does async/await work in Python 3.5?

Python协程：从yield/send到async/await

Python黑魔法 --- 异步IO（ asyncio） 协程

Keynote at PyCon Brasil 2015 (Screencast)

Tags: asyncio、IO、lightless@Meili-inc、Python、Python协程从零开始到放弃、异步编程

 

转自 https://www.secpulse.com/archives/61398.html