IO异步

共计 3007 个字符，预计需要花费 8 分钟才能阅读完成。

一、说明

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

二、回调写法实现原理

​“`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 执行并进行监视回调