2. 程式人生 > >利用tornado使請求實現異步非阻塞

利用tornado使請求實現異步非阻塞

阿新 • • 發佈：2019-01-01
-a 源碼 == spa and 沒有 個人 pass method

基本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
來源：簡書
簡書著作權歸作者所有，任何形式的轉載都請聯系作者獲得授權並註明出處。

利用tornado使請求實現異步非阻塞

相關推薦

利用tornado使請求實現異步非阻塞

-a 源碼 == spa and 沒有 個人 pass method 基本IO模型 網上搜了很多關於同步異步，阻塞非阻塞的說法，理解還是不能很透徹，有必要買書看下。 參考：使用異步 I/O 大大提高應用程序的性能 怎樣理解阻塞非阻塞與同步異步的區別？ 同步和異步：主

利用tornado使請求實現非同步非阻塞

基本IO模型 網上搜了很多關於同步非同步，阻塞非阻塞的說法，理解還是不能很透徹，有必要買書看下。 參考：使用非同步 I/O 大大提高應用程式的效能 怎樣理解阻塞非阻塞與同步非同步的區別？ 同步和非同步：主要關注訊息通訊機制（重點在B？）。 同步：A呼叫B，B處理直到獲得結

Python web框架 Tornado（二）異步非阻塞

.py thread bind log class multiple fin ini lex 異步非阻塞 阻塞式：(適用於所有框架，Django,Flask,Tornado,Bottle) 　　一個請求到來未處理完成，後續一直等待 　　解決方案：多線程，多進程 異步

異步非阻塞socket的實現

print except 事件循環 port int 性能 run utf8 try 在學習使用scrapy爬蟲框架之前，需要了解一些基礎原理 　　我們知道HTTP請求是基於socket模塊進行發送和接受的，但是socket套接字的在使用的中存在著阻塞，不利用爬蟲的高性能運

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

發送數據 star opened prope asd 等待 page 設置 使用 Tornado 和現在的主流 Web 服務器框架（包括大多數 Python 的框架）有著明顯的區別：它是非阻塞式服務器，而且速度相當快。得利於其 非阻塞的方式和對 epoll 的運用，To

nodejs的異步非阻塞IO

nbsp png 使用 nod .com 輪詢 cnblogs 分享 strong 簡單表述一下：發啟向系統IO操作請求，系統使用線程池IO操作，執行完放到事件隊列裏，node主線程輪詢事件隊列，讀取結果與調用回調。所以說node並非真的單線程，還是使用了線程池的多線程。

爬蟲必備—性能相關（異步非阻塞）

tornado 異步io 主機 quest cookie article Coding aps 技術 在編寫爬蟲時，性能的消耗主要在IO請求中，當單進程單線程模式下請求URL時必然會引起等待，從而使得請求整體變慢。 1. 同步執行 1 import requests

200行自定義異步非阻塞Web框架

object sock key break bin 準備就緒 ram host style Python的Web框架中Tornado以異步非阻塞而聞名。本篇將使用200行代碼完成一個微型異步非阻塞Web框架：Snow。 一、源碼 本文基於非阻塞的Socket以及I

同步阻塞同步非阻塞異步阻塞異步非阻塞--簡明介紹

同步異步阻塞非阻塞同步、異步：針對發送方阻塞、非阻塞：針對接收方發送方接收方發送方處理接收方處理同步阻塞等待接收方返回等待處理結果返回發送方同步非阻塞等待接收方返回不等待處理結果，去做其他事情異步阻塞不等待接受方返回等待處理結果返回發送方異步非阻塞不等待接受方返回不等待處理結果，去做其他事情本文出自 “Lin

爬蟲提高性能：串行、線程進程、異步非阻塞

過程 p s eight [] open 接收 text future io模型 閱讀目錄 一 背景知識 二 同步、異步、回調機制 三 高性能 一 背景知識 爬蟲的本質就是一個socket客戶端與服務端的通信過程，如果我們有多個url待爬取，只用一個線程

Python的異步編程[0] -> 協程[1] -> 使用協程建立自己的異步非阻塞模型

.net post this fab htm true 底層實現 自己 print 使用協程建立自己的異步非阻塞模型 接下來例子中，將使用純粹的Python編碼搭建一個異步模型，相當於自己構建的一個asyncio模塊，這也許能對asyncio模塊底層實現的理解有更大的

Java異步非阻塞IO NIO使用與代碼分析

package mes 127.0.0.1 back 之一 write throwable private 建立 [TOC] Java異步非阻塞IO NIO使用與代碼分析 TimeServer程序的NIO實現完整代碼 TimeServer程序來自書本《Netty權威指南》

35 並行/發 同/異步 非/ 阻塞 進程的兩種開啟方式, 進程的常用方法及屬性

self 屬性 任務序列 設置 並行 告訴 方法 main 解釋器 主要內容: 1 名詞解釋 並行 : 即兩件事情或多件事情,在同一時間點同時執行.是從微觀上，也就是在一個精確的時間片刻，有不同的程序在執行，這就要求必須有多個處理器 並發 : 即兩件事情或多件事情在

NIO：異步非阻塞I/O，AIO，BIO

group 互聯 handle 通知機制 down 行處理 java 概念 建立連接 Neety的基礎使用及說明 https://www.cnblogs.com/rrong/p/9712847.html BIO(缺乏彈性伸縮能力，並發量小，容易出現內存溢出，出現宕機 每一個

python學習筆記之四-多進程&多線程&異步非阻塞

running executor 服務器 RoCE 進行 break python buffer 創建 ProcessPoolExecutor對multiprocessing進行了高級抽象，暴露出簡單的統一接口。 異步非阻塞 爬蟲 對於異步IO請求的本質則是【非阻塞So

ios網絡學習------3 用非代理方法實現異步post請求

erro form b2c enc 界面 關聯 error pre mut #pragma mark - 這是私有方法。盡量不要再方法中直接使用屬性,由於一般來說屬性都是和界面關聯的，我們能夠通過參數的方式來使用屬性 #pragma mark post登錄方法 -(v

利用gevent實現異步執行任務

實現python 異步執行import gevent def task(pid): gevent.sleep(2) print ("task %s done"%pid) def asynchronous(): threads = [gevent.spawn(tas

Android 實現異步加載圖片

nba while amp android pub 數據 bool 一段時間 代碼 麥洛開通博客以來,有一段時間沒有更新博文了.主要是麥洛這段時間因項目開發實在太忙了.今天周六還在公司加班,苦逼程序猿都是這樣生活的. 今天在做項目的時候,有一個實現異步加載圖片的功能,雖然比

jquery.form.js 實現異步上傳

llb element eth document == ctype tostring detail new 前臺： <form id="formSeacrh" action="/ResumeInfo/uploadFile" method="post" enctype

struts+ajax+jquery：實現異步新增數據

sim orm html 沖突 lin itl nac 處理 ajax請求 很久未有更新，最近因為團隊其它事耽誤沒有繼續學習，但心中十分忐忑不安，抽空把自己薄弱的點拿來再鞏固一下！ 本身異步刷新用處非常多，SSH框架對我來講，已無難度，但結合ajax處理一些增刪查改分頁等，