理解 Python 协程的本质

def handler(request):    # 处理请求    pass
# 你的 handler 运行在 while 循环中while True:    # 获取一个新请求    request = accept()    # 根据路由映射获取到用户写的业务逻辑函数    handler = get_handler(request)    # 运行用户的handler，处理请求    handler(request)

# 操作系统的IO复用示例伪代码io_register(io_id, io_type)  # 向操作系统io注册自己关注的io操作的id和类型io_register(io_id, io_type)# 获取完成的io操作, 使用 epoll() in Linux and kqueue() in Unixevents = io_get_finished()
for (io_id, io_type) in events:    if io_type == READ:        data = read_data(io_id)    elif io_type == WRITE:        write_data(io_id，data)

call_backs = {}
def handler(req):    # do jobs here    io_register(io_id, io_type)    def call_back(result):    # 使用返回的result完成剩余工作    call_backs[io_id] = call_back
# 新的循环while True：    # 获取已经完成的io事件    events = io_get_finished()    for (io_id, io_type) in events:        if io_type == READ: # 读取            data = read(io_id)            call_back = call_backs[io_id]            call_back(data)        else:            # 其他类型io事件的处理            pass
    # 获取一个新请求    request = accept()    # 根据路由映射获取到用户写的业务逻辑函数    handler = get_handler(request)    # 运行用户的handler，处理请求    handler(request)

def handler(request):    # 业务逻辑代码
    # 需要执行一次API请求    def call_back(result):        # 使用API返回的result完成剩余工作        print(result)    # 注册回调，没有io_call这个方法，仅示意，表示注册一个io操作    asyncio.get_event_loop().io_call(api, call_back)

def example():    value = yield 2    print("get", value)    return value
g = example()# 使用send(None)启动生成器，我们应该会得到 2got = g.send(None)print(got)  # 2
try:    # 再次启动 会显示 "get 4", 就是我们传入的值    got = g.send(got*2)except StopIteration as e:    # 生成器运行完成，将会print(4)，e.value 是生成器return的值    print(e.value)

def handler(request):    # 业务逻辑代码
    # 需要执行一次API请求，直接把IO请求信息yield出去    result = yield io_info    # 使用API返回的result完成剩余工作    print(result)
# 这个函数注册到ioloop中，用来当有新请求的时候回调def on_request(request):    # 根据路由映射获取到用户写的业务逻辑函数    handler = get_handler(request)    g = handler(request)    # 首次启动获得io_info    io_info = g.send(None)
    # io完成回调函数    def call_back(result):        g.send(result)  # 重新启动生成器
    asyncio.get_event_loop().io_call(io_info, call_back)

def func1():    ret = yield request("http://test.com/foo")    ret = yield func2(ret)    return ret
def func2(data):    result = yield request("http://test.com/"+data)    return result
def request(url):    # 这里模拟返回一个io操作，包含io操作的所有信息，这里用URL简化    result = yield "iojob of %s" % url    return result

def wrapper(gen):    # 第一层调用 入栈    stack = Stack()    stack.push(gen)
    # 开始逐层调用    while True:        # 获取栈顶元素        item = stack.peak()
        result = None        if isgenerator(item):  # 生成器，            try:                # 尝试获取下个生成器调用，并入栈                # result 初始为None，之后迭代中将为下层调用的返回值                child = item.send(result)                result = None                stack.push(child)                # 入栈后直接进入下次循环，继续深入调用链                continue            except StopIteration as e:                # 如果自己运行结束了，就暂存result，下一步让自己出栈                result = e.value        else:  # io 操作            # 遇到了io操作，yield出去            # IO完成后会被用IO结果唤醒并暂存到result            result = yield item
        # 走到这里则本层已经执行完毕，出栈，下次迭代将回到调用链上一层        stack.pop()        # 没有上一层的话，那整个调用链都执行完成了，return        if stack.empty():            print("finished")            return result

w = wrapper(func1())# 启动 wrpper, 将会得到 "iojob of http://test.com/foo"w.send(None)# 上个iojob foo 完成后的结果"bar"传入，继续运行，得到  "iojob of http://test.com/bar"w.send("bar")# 上个iojob bar 完成后的结构"barz"传入，继续运行，结束。w.send("barz")

# 维护一个就绪列表，存放所有完成的IO事件，格式为（wrapper，result）ready = []
def on_request(request):    handler = get_handler(request)    # 使用 wrapper 包装后，可以只通过send处理IO了    g = wrapper(func1())    # 把开始状态直接视为结果为None的就绪状态    ready.append((g, None))
# 让ioloop每轮循环都执行此函数，用来处理的就绪的IO，def process_ready(self):    def call_back(g, result):        ready.append((g, result))
    # 遍历所有已经就绪生成器，将其向下推进    for g, result in self.ready:        # 用result唤醒生成器，并得到下一个io操作        io_job = g.send(result)        asyncio.get_event_loop().io_call(  # 注册io操作            io_job,            # 完成后把生成器加入就绪列表，等待下一轮处理            lambda result: ready.append((g, result)        )

class Future：    # 设置结果    def set_result(result): pass    # 获取结果    def result():  pass    # 表示这个future对象是fou已被设置过结果    def done(): pass    # 设置在他被设置结果时应该执行的回调函数，可以设置多个    def add_done_callback(callback):  pass

# 现在 request 函数，不是生成器，它返回futuredef request(url):    # future 理解为占位符    fut = Future()
    def callback(result):        # 当网络IO完成回调的时候给占位符赋值        fut.set_result(result)    # 注册回调    asyncio.get_event_loop().io_call(url, callback)
    # 返回占位符    return future

def process_ready(self):    def callback(fut):        # future被设置结果会被放入就绪列表        ready.append((g, fut.result()))
    # 遍历所有已经就绪生成器，将其向下推进    for g, result in self.ready:        # 用result唤醒生成器，得到的不再是io操作，而是future        fut = g.send(result)        # future被设置结果的时候会调用callback        fut.add_done_callback(callback)

def func1():    # 注意 yield from    ret = yield from request("http://test.com/foo")    ret = yield from func2(ret)    return ret
def func2(data):    # 注意 yield from    result = yield from request("http://test.com/"+data)    return result
def request(url):    # 同上基于future实现的request    pass

g = func1()# 返回第一个请求的 futureg.send(None)# 继续运行，进入func2 并得到第它里面的那个futureg.send("bar")# 继续运行，完成调用链剩余逻辑，抛出StopIteration异常g.send("barz")