利用tornado使请求实现异步非阻塞

基本IO模型

网上搜了很多关于同步异步，阻塞非阻塞的说法，理解还是不能很透彻，有必要买书看下。

参考：使用异步 I/O 大大提高应用程序的性能

怎样理解阻塞非阻塞与同步异步的区别？

  1. 同步和异步：主要关注消息通信机制（重点在B？）。

    同步：A调用B，B处理直到获得结果，才返回给A。

    异步：A调用B，B直接返回。无需等待结果，B通过状态，通知等来通知A或回调函数来处理。

  2. 阻塞和非阻塞：主要关注程序等待（重点在A？）。

    阻塞：A调用B，A被挂起直到B返回结果给A，A继续执行。

    非阻塞：A调用B，A不会被挂起，A可以执行其他操作（但可能A需要轮询检查B是否返回）。

  3. 同步阻塞：A调用B，A挂起，B处理直到获得结果，返回给A，A继续执行。
  4. 同步非阻塞：A调用B，A继续执行，B处理直到获得结果，处理的同时A轮询检查B是否返回结果。
  5. 异步阻塞：异步阻塞 I/O 模型的典型流程 (select)。
  6. 异步非阻塞：A调用B，B立即返回，A继续执行，B得到结果后通过状态，通知等通知A或回调函数处理。
tornado实现异步非阻塞

参考：

  1. 使用tornado让你的请求异步非阻塞
  2. 官方文档
利用异步方法（回调）和@tornado.web.asynchronous

@tornado.web.asynchronous 并不能将一个同步方法变成异步，所以修饰在同步方法上是无效的，只是告诉框架，这个方法是异步的，且只能适用于HTTP verb方法（get、post、delete、put等）。@tornado.web.asynchronous 装饰器适用于callback-style的异步方法，如果是协程则可以用@tornado.gen.coroutine来修饰。对于用@tornado.web.asynchronous 修饰的异步方法，需要主动self.finish()来结束该请求，普通的方法(get()等)会自动结束请求在方法返回的时候。

最基本的使用callback-style的例子，直接使用异步方法，并定义callback方法。

# sync blocking
class SleepHandler(BaseHandler):

    # no effective
    @tornado.web.asynchronous
    def get(self):
        time.sleep(5)
        self.write(‘sleep for 5s‘)

class SleepHandler(BaseHandler):

    @tornado.web.asynchronous
    def get(self):
        tornado.ioloop.IOLoop.instance().add_timeout(time.time() + 5, callback=self.on_response)

    def on_response(self):
        self.write(‘sleep for 5s‘)
        self.finish()

# call back
class MyRequestHandler(BaseHandler):
    @tornado.web.asynchronous
    def get(self):
        http = httpclient.AsyncHTTPClient()
        http.fetch(‘http://www.baidu.com‘, self._on_download)

    def _on_download(self, response):
        self.write(response.body)
        self.finish()
利用ThreadPoolExecutor

利用ThreadPoolExecutor的submit和future对象的add_done_callback 方法，将一个同步方法变成异步。如下例所示，若没有无参可以不用partial()：

class SleepHandler(BaseHandler):
    @tornado.web.asynchronous
    def get(self):
        sleep_time = 5

        def callback(future):
            self.write(future.result())
            self.finish()

        EXECUTOR.submit(partial(self.get_sleep, sleep_time)).add_done_callback(
            lambda future: tornado.ioloop.IOLoop.instance().add_callback(
                partial(callback, future)))

    def get_sleep(self, sleep_time):
        time.sleep(sleep_time)
        return "Awake! %s" % time.time()

分解一下：

  1. future = EXECUTOR.submit(partial(self.get_sleep, sleep_time))返回了一个future对象。
  2. future.add_done_callback() 给future添加一个完成回调函数callback_func。
  3. 实际上这个回调函数是
callback_func = lambda future: tornado.ioloop.IOLoop.instance().add_callback(partial(callback, future))```
4. 结合起来就是：

class SleepHandler(BaseHandler):

@tornado.web.asynchronous

def get(self):

sleep_time = 5

    def final_callback(future_param):
        self.write(future_param.result())
        self.finish()

    def executor_callback(future_param):
        tornado.ioloop.IOLoop.instance().add_callback(partial(final_callback, future_param))

    future = EXECUTOR.submit(partial(self.get_sleep, sleep_time))
    future.add_done_callback(executor_callback)

def get_sleep(self, sleep_time):
    time.sleep(sleep_time)
    return "Awake! %s" % time.time()

5. 没看文档，源码前本认为为什么要多此一举进行两次callback，直接

tornado.ioloop.IOLoop.instance().add_callback(partial(final_callback, future))

不就ok了吗，为何还要再加上一层

future.add_done_callback(executor_callback)

但发现直接这样是会阻塞IOLoop的。查阅相关文档后发现，```
tornado.ioloop.IOLoop.instance().add_callback
``` 这个方法会将控制权从其他线程转到IOLoop线程上，直接用

tornado.ioloop.IOLoop.instance().add_callback(partial(final_callback, future))

时，final_callback()中获取future_param.result()仍然会阻塞，所以需要future.add_done_callback()```，在该线程完成获取结果后在回callback给IOLoop。


另一种类似的写法，将上例的方法写成了一个装饰器，见下例，但个人认为利用这种方式异步时没有必要单独写一个装饰器吧，而且也不通用吧？

def unblock(f):
    @tornado.web.asynchronous
    @wraps(f)
    def wrapper(*args, **kwargs):
        self = args[0]

        def callback(future):
            self.write(future.result())
            self.finish()
        EXECUTOR.submit(
            partial(f, *args, **kwargs)
        ).add_done_callback(
            lambda future: tornado.ioloop.IOLoop.instance().add_callback(
                partial(callback, future)))
    return wrapper

class SleepHandler(BaseHandler):
    @unblock
    def get(self):
        time.sleep(5)
        return "Awake! %s" % time.time()
使用tornado.concurrent.run_on_executor简化

上述的两例都相当于开启了新的线程池？

除此之外还可以利用@run_on_executor装饰器将同步阻塞函数变成异步（或者说被tornado的装饰器理解和识别）。首先阅读一下@run_on_executor源码：

def run_on_executor(*args, **kwargs):
    """Decorator to run a synchronous method asynchronously on an executor.

    The decorated method may be called with a ``callback`` keyword
    argument and returns a future.

    The `.IOLoop` and executor to be used are determined by the ``io_loop``
    and ``executor`` attributes of ``self``. To use different attributes,
    pass keyword arguments to the decorator::

        @run_on_executor(executor=‘_thread_pool‘)
        def foo(self):
            pass

    .. versionchanged:: 4.2
       Added keyword arguments to use alternative attributes.
    """
    def run_on_executor_decorator(fn):
        executor = kwargs.get("executor", "executor")
        io_loop = kwargs.get("io_loop", "io_loop")

        @functools.wraps(fn)
        def wrapper(self, *args, **kwargs):
            callback = kwargs.pop("callback", None)
            future = getattr(self, executor).submit(fn, self, *args, **kwargs)
            if callback:
                getattr(self, io_loop).add_future(
                    future, lambda future: callback(future.result()))
            return future
        return wrapper
    if args and kwargs:
        raise ValueError("cannot combine positional and keyword args")
    if len(args) == 1:
        return run_on_executor_decorator(args[0])
    elif len(args) != 0:
        raise ValueError("expected 1 argument, got %d", len(args))
    return run_on_executor_decorator

可以很快发现在不存在callback关键字参数时，该装饰器返回了一个future对象，由此并结合上述两例子可以很快的利用@run_on_executor写出，感觉相当于简化了上述两例的代码并使之变得通用：

class SleepHandler(BaseHandler):

    executor = ThreadPoolExecutor(2)

    @tornado.web.asynchronous
    def get(self):
        def callback(future_param):
            self.write(‘sleep %ss‘ % future_param.result())
            self.finish()

        future = self.sleep()
        future.add_done_callback(lambda f: tornado.ioloop.IOLoop.instance().add_callback(
                partial(callback, f)))

    @run_on_executor
    def sleep(self):
        time.sleep(5)
        return 5

当然也可以利用callback参数：

class SleepHandler(BaseHandler):
    executor = ThreadPoolExecutor(2)
    io_loop = tornado.ioloop.IOLoop.instance()

    @tornado.web.asynchronous
    def get(self):
        def callback(res):
            self.write(‘sleep %ss‘ % res)
            self.finish()

        self.sleep(callback=callback)

    @run_on_executor
    def sleep(self):
        time.sleep(5)
        return 5
协程方式：@tornado.gen.coroutine和yield

除了上述的用利用@tornado.web.asynchronous和callback的方式，还可以用@tornado.gen.coroutine和yield，如下例子：

class GenRequestHandler(BaseHandler):
    @tornado.gen.coroutine
    def get(self):
        http = httpclient.AsyncHTTPClient()
        res = yield http.fetch(‘http://www.baidu.com‘)
        self.write(res.body)

参考官方文档

Most asynchronous functions in Tornado return a Future; yielding this object returns its result.

利用tornado.gen.Task修饰一个callback型的异步函数使其能够与yield使用。

gen.Task is now a function that returns a Future

看一下例子(对于sleep可以直接用yield tornado.gen.sleep(5))：

# gen.Task
class SleepHandler(BaseHandler):

    @tornado.gen.coroutine
    def get(self):
        yield tornado.gen.Task(tornado.ioloop.IOLoop.instance().add_timeout, time.time() + 5)
        # yield tornado.gen.sleep(5)
        self.write(‘sleep for 5s‘)

还可以用结合celery使用（但并不是最好的方案）。

Last

https://github.com/tornadoweb/tornado/wiki/Links tornado的wiki上有很多异步相关支持的库。

作者：蒋狗
链接：https://www.jianshu.com/p/ef01c1386933
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

原文地址：https://www.cnblogs.com/b02330224/p/10203414.html

时间： 2024-08-25 11:59:34

利用tornado使请求实现异步非阻塞的相关文章

使用tornado让你的请求异步非阻塞

http://www.dongwm.com/archives/shi-yong-tornadorang-ni-de-qing-qiu-yi-bu-fei-zu-sai/?utm_source=tuicool&utm_medium=referral 前言 也许有同学很迷惑:tornado不是标榜异步非阻塞解决10K问题的嘛?但是我却发现不是torando不好,而是你用错了.比如最近发现一个事情:某网站打开页面很慢,服务器cpu/内存都正常.网络状态也良好. 后来发现,打开页面会有很多请求后端数据库

初始Tornado异步非阻塞

Tornado  异步非阻塞 from tornado import gen class MainHandler(tornado.web.RequestHandler): @gen.coroutine  #关键点 def get(self): futrue =Future()#关键点 #阻塞内容,必须写这个格式,time.sleep不好使 #tornado.ioloop.IOLoop.current().add_timeout(time.time()+10,self.doing) #关键点 se

Tornado的异步非阻塞

阻塞和非阻塞Web框架 只有Tornado和Node.js是异步非阻塞的,其他所有的web框架都是阻塞式的. Tornado阻塞和非阻塞两种模式都支持. 阻塞式: 代表:Django.Flask.Tornado.Bottle 一个请求到来未处理完成,后续请求则一直等待. 解决方案:多线程或多进程. 异步非阻塞(存在IO请求): 代表:Tornado(默认单进程/单线程) Tornado的阻塞模式示例 from tornado import ioloop from tornado.web impo

Tornado异步非阻塞的使用以及原理

Tornado 和现在的主流 Web 服务器框架(包括大多数 Python 的框架)有着明显的区别:它是非阻塞式服务器,而且速度相当快.得利于其 非阻塞的方式和对 epoll 的运用,Tornado 每秒可以处理数以千计的连接,这意味着对于实时 Web 服务来说,Tornado 是一个理想的 Web 框架. 一.Tornado的两种模式使用 1.同步阻塞模式 由于doing中sleep10秒,此时其他连接将被阻塞,必须等这次请求完成后其他请求才能连接成功. 1 import tornado.io

异步非阻塞IO的Python Web框架--Tornado

Tornado的全称是Torado Web Server,从名字上就可知它可用作Web服务器,但同时它也是一个Python Web的开发框架.最初是在FriendFeed公司的网站上使用,FaceBook收购之后便进行了开源. 作为Web框架,是一个轻量级的Web框架,类似于另一个Python web 框架Web.py,其拥有异步非阻塞IO的处理方式. 作为Web服务器,Tornado有较为出色的抗负载能力,官方用nginx反向代理的方式部署Tornado和其它Python web应用框架进行对

异步非阻塞

首先讨论下使用事件驱动,异步编程的优点: 充分利用了系统资源,执行代码无须阻塞等待某种操作完成,有限的资源可以用于其他的任务.其非常适合于后端的网络服务编程. 在服务器开发中,并发的请求处理是个大问题,阻塞式的函数会导致资源浪费和时间延迟.通过事件注册.异步函数,开发人员可以提高资源的利用率,性能也会改善.其nginx和node.js处理并发都是采用的事件驱动异步非阻塞模式.其中nginx中处理并发用的是epoll,poll,queue等方式,node.js使用的是libev,它们对大规模的HT

Linux-同步异步非阻塞阻塞的解析

一.理解同步.异步.阻塞.非阻塞 出场人物:老张,水壶两把(普通水壶,简称水壶:会响的水壶,简称响水壶). 1 老张把水壶放到火上,立等水开.(同步阻塞) 老张觉得自己有点傻. 2 老张把水壶放到火上,去客厅看电视,时不时去厨房看看水开没有.(同步非阻塞) 老张还是觉得自己有点傻,于是变高端了,买了把会响笛的那种水壶.水开之后,能大声发出嘀~~~~的噪音. 3 老张把响水壶放到火上,立等水开.(异步阻塞) 老张觉得这样傻等意义不大. 4 老张把响水壶放到火上,去客厅看电视,水壶响之前不再去看它了

爬虫必备—性能相关（异步非阻塞）

在编写爬虫时,性能的消耗主要在IO请求中,当单进程单线程模式下请求URL时必然会引起等待,从而使得请求整体变慢. 1. 同步执行 1 import requests 2 3 def fetch_async(url): 4 response = requests.get(url) 5 return response 6 7 8 url_list = ['http://www.github.com', 'http://www.bing.com'] 9 10 for url in url_list:

200行自定义异步非阻塞Web框架

Python的Web框架中Tornado以异步非阻塞而闻名.本篇将使用200行代码完成一个微型异步非阻塞Web框架:Snow. 一.源码 本文基于非阻塞的Socket以及IO多路复用从而实现异步非阻塞的Web框架,其中便是众多异步非阻塞Web框架内部原理. #!/usr/bin/env python # -*- coding:utf-8 -*- import re import socket import select import time class HttpResponse(object)