Tornado 异步浅解

Posted zhangmingda

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Tornado 异步浅解相关的知识,希望对你有一定的参考价值。

7.1 认识异步

1. 同步

我们用两个函数来模拟两个客户端请求,并依次进行处理:

#!/usr/bin/env python3
# -*- coding:utf-8 -*-
#  @Time: 2020/3/9 11:15
#  @Author:zhangmingda
#  @File: asynchronization.py
#  @Software: PyCharm
#  Description:了解异步工作原理
def req_a():
    ‘‘‘模拟请求A‘‘‘
    print(开始处理请求A)
    print(完成处理请求A)

def req_b():
    ‘‘‘模拟请求A‘‘‘
    print(开始处理请求B)
    print(完成处理请求B)
def main():
    """模拟tornado框架,处理两个请求"""
    req_a()
    req_b()

if __name__ == "__main__":
    main()

执行结果:

D:Python3_study ornado1Scriptspython.exe D:/Python3_study/tornado1/asynchronization.py
开始处理请求A
完成处理请求A
开始处理请求B
完成处理请求B

同步是按部就班的依次执行,始终按照同一个步调执行,上一个步骤未执行完不会执行下一步。

想一想,如果在处理请求req_a时需要执行一个耗时的工作(如IO),其执行过程如何?

import time


def req_a():
    ‘‘‘模拟请求A‘‘‘
    print(开始处理请求A)
    long_io()
    print(完成处理请求A)

def req_b():
    ‘‘‘模拟请求A‘‘‘
    print(开始处理请求B)
    print(完成处理请求B)
def main():
    """模拟tornado框架,处理两个请求"""
    req_a()
    req_b()
def long_io():
    ‘‘‘模拟耗时的IO操作‘‘‘
    print(开始IO操作)
    time.sleep(5)
    print("完成IO操作")
    return "IO Complate!!"

if __name__ == "__main__":
    main()

执行过程:

D:Python3_study ornado1Scriptspython.exe D:/Python3_study/tornado1/asynchronization.py
开始处理请求A
开始IO操作
完成IO操作
完成处理请求A
开始处理请求B
完成处理请求B

在上面的测试中,我们看到耗时的操作会将代码执行阻塞住,即req_a未处理完req_b是无法执行的。

我们怎么解决耗时操作阻塞代码执行?

2. 异步

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

我们用容易理解的线程机制来实现异步。

2.1 回调写法实现原理

# coding:utf-8

import time
import thread

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

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()
    while 1: # 添加此句防止程序退出,保证线程可以执行完
        pass

if __name__ == ‘__main__‘:
    main()

执行过程:

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

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

2.2 协程写法实现原理

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

回想yield关键字的作用?

初始版本

# coding:utf-8

import time
import thread

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
    thread.start_new_thread(fun, ())

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()
    gen.next() # 开启生成器req_a的执行
    req_b()
    while 1:
        pass

if __name__ == ‘__main__‘:
    main()

执行过程:

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

升级版本

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

现在,我们试图尝试修改,让req_a与main的编写都类似与同步代码。

# coding:utf-8

import time
import thread

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

def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        global gen
        gen = f()
        gen.next()
    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
    thread.start_new_thread(fun, ())

@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()
    while 1:
        pass

if __name__ == ‘__main__‘:
    main()

执行过程:

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

最终版本

刚刚完成的版本依然不理想,因为存在一个全局变量gen来供long_io使用。我们现在再次改写程序,消除全局变量gen。

# coding:utf-8

import time
import thread

def gen_coroutine(f):
    def wrapper(*args, **kwargs):
        gen_f = f()  # gen_f为生成器req_a
        r = gen_f.next()  # r为生成器long_io
        def fun(g):
            ret = g.next() # 执行生成器long_io
            try:
                gen_f.send(ret) # 将结果返回给req_a并使其继续执行
            except StopIteration:
                pass
        thread.start_new_thread(fun, (r,))
    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()
    while 1:
        pass

if __name__ == ‘__main__‘:
    main()

执行过程:

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

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

需要注意的一点是,我们实现的版本严格意义上来说不能算是协程,因为两个程序的挂起与唤醒是在两个线程上实现的,而Tornado利用epoll来实现异步,程序的挂起与唤醒始终在一个线程上,由Tornado自己来调度,属于真正意义上的协程。虽如此,并不妨碍我们理解Tornado异步编程的原理。

思考

  1. Tornado里的异步就是协程,这句话对吗?
  2. Tornado中出现yield就是异步,这句话对吗?
  3. 怎么理解yield将程序挂起?在Tornado中又如何理解yield挂起程序实现异步?

以上是关于Tornado 异步浅解的主要内容,如果未能解决你的问题,请参考以下文章

Python Web框架Tornado的异步处理代码演示样例

tornado异步原理

tornado 启动WSGI应用(Flask)使用多线程将同步代码变成异步

Python Web框架Tornado的异步处理代码示例

tornado异步原理——高并发

Python 使用 Tornado Web 框架写HTTP接口实例代码(异步+线程池)