IO异步-组团学

一、说明

对于耗时的过程，我们将其交给别人（如其另外一个线程）去执行，而我们继续往下处理，当别人执行完耗时操作后再将结果反馈给我们，这就是我们所说的异步

二、回调写法实现原理

```python
import time
import threading

def long_io(callback):
“”“将耗时的操作交给另一线程来处理”""
def fun(cb): # 回调函数作为参数
“”“耗时操作”""
print(“开始执行IO操作”)
time.sleep(5)
print(“完成IO操作，并执行回调函数”)
cb(“io result”) # 执行回调函数
threading.Thread(target=fun, args=(callback,)).start() # 开启线程执行耗时操作

def on_finish(ret):
“”“回调函数”""
print(“开始执行回调函数on_finish”)
print(“ret: %s” % ret)
print(“完成执行回调函数on_finish”)

def req_a():
print(“开始处理请求req_a”)
long_io(on_finish)
print(“离开处理请求req_a”)

def req_b():
print(“开始处理请求req_b”)
time.sleep(2) # 添加此句来突出显示程序执行的过程
print(“完成处理请求req_b”)

def main():
req_a()
req_b()

if name == ‘main’:
main()


执行过程:

开始处理请求req_a
开始执行IO操作
离开处理请求req_a
开始处理请求req_b
完成处理请求req_b
完成IO操作，并执行回调函数
开始执行回调函数on_finish
ret: io result
完成执行回调函数on_finish


说明：异步的特点是程序存在多个步调，即本属于同一个过程的代码可能在不同的步调上同时执行

三、协程写法实现原理

说明

在使用回调函数写异步程序时，需将本属于一个执行逻辑（处理请求a）的代码拆分成两个函数req_a和on_finish，这与同步程序的写法相差很大。而同步程序更便于理解业务逻辑，所以我们能否用同步代码的写法来编写异步程序

初始版本

import time
import threading

gen = None  # 全局生成器，供long_io使用

def long_io():
    def fun():
        print("开始执行IO操作")
        global gen
        time.sleep(5)
        try:
            print("完成IO操作，并send结果唤醒挂起程序继续执行")
            gen.send("io result")  # 使用send返回结果并唤醒程序继续执行
        except StopIteration: # 捕获生成器完成迭代，防止程序退出
            pass
    threading.Thread(target=fun).start()

def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")

def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print("完成处理请求req_b")

def main():
    global gen
    gen = req_a()
    next(gen) # 开启生成器req_a的执行
    req_b()


if __name__ == '__main__':
    main()

执行过程：

  开始处理请求req_a
  开始执行IO操作
  开始处理请求req_b
  完成处理请求req_b
  完成IO操作，并send结果唤醒挂起程序继续执行
  ret: io result
  完成处理请求req_a

升级版本

说明：我们在上面编写出的版本虽然req_a的编写方式很类似与同步代码，但是在main中调用req_a的时候却不能将其简单的视为普通函数，而是需要作为生成器对待

import time
import threading

gen = None  # 全局生成器，供long_io使用

def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        global gen
        gen = f()
        next(gen)
    return wrapper

def long_io():
    def fun():
        print("开始执行IO操作")
        global gen
        time.sleep(5)
        try:
            print("完成IO操作，并send结果唤醒挂起程序继续执行")
            gen.send("io result")  # 使用send返回结果并唤醒程序继续执行
        except StopIteration: # 捕获生成器完成迭代，防止程序退出
            pass
    threading.Thread(target=fun).start()

@gen_coroutine
def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")

def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print("完成处理请求req_b")

def main():
    req_a()
    req_b()


if __name__ == '__main__':
    main()

执行过程：

  开始处理请求req_a
  开始执行IO操作
  开始处理请求req_b
  完成处理请求req_b
  完成IO操作，并send结果唤醒挂起程序继续执行
  ret: io result
  完成处理请求req_a

最终版本

import time
import threading

def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        gen_f = f()  # gen_f为生成器req_a
        r = next(gen_f)  # r为生成器long_io
        def fun(g):
            ret = next(g) # 执行生成器long_io
            try:
                gen_f.send(ret) # 将结果返回给req_a并使其继续执行
            except StopIteration:
                pass
        threading.Thread(target=fun, args=(r,)).start()
    return wrapper

def long_io():
    print("开始执行IO操作")
    time.sleep(5)
    print("完成IO操作，yield回操作结果")
    yield "io result"

@gen_coroutine
def req_a():
    print("开始处理请求req_a")
    ret = yield long_io()
    print("ret: %s" % ret)
    print("完成处理请求req_a")

def req_b():
    print("开始处理请求req_b")
    time.sleep(2)
    print("完成处理请求req_b")

def main():
    req_a()
    req_b()


if __name__ == '__main__':
    main()

执行过程：

  开始处理请求req_a
  开始执行IO操作
  开始处理请求req_b
  完成处理请求req_b
  完成IO操作，yield回操作结果
  ret: io result
  完成处理请求req_a

说明：这个最终版本就是理解Tornado异步编程原理的最简易模型，但是，Tornado实现异步的机制不是线程，而是epoll，即将异步过程交给epoll执行并进行监视回调