tornado异步

最新推荐文章于 2021-03-01 07:39:45 发布

BrownWong

最新推荐文章于 2021-03-01 07:39:45 发布

阅读量635

点赞数

分类专栏： python 文章标签： tornado 异步

本文链接：https://blog.csdn.net/qq_16912257/article/details/78705587

版权

python 专栏收录该内容

116 篇文章 0 订阅

订阅专栏

1. 理论

（1）同步IO

CPU的速度远远快于磁盘、网络等IO。在一个线程中，CPU执行代码的速度极快，然而，一旦遇到IO操作，如读写文件、发送网络数据时，就需要等待IO操作完成，才能继续进行下一步操作。这种情况称为同步IO。

因为一个IO操作就阻塞了当前线程，导致其他代码无法执行，所以我们必须使用多线程或者多进程来并发执行代码，为多个用户服务。每个用户都会分配一个线程，如果遇到IO导致线程被挂起，其他用户的线程不受影响。
多线程和多进程的模型虽然解决了并发问题，但是系统不能无上限地增加线程。由于系统切换线程的开销也很大，所以，一旦线程数量过多，CPU的时间就花在线程切换上了，真正运行代码的时间就少了，结果导致性能严重下降。

（2）异步IO

另一种解决IO问题的方法是异步IO。当代码需要执行一个耗时的IO操作时，它只发出IO指令，并不等待IO结果，然后就去执行其他代码了。一段时间后，当IO返回结果时，再通知CPU进行处理。

异步IO模型需要一个消息循环，在消息循环中，主线程不断地重复“读取消息-处理消息”这一过程：

loop = get_event_loop()
while True:
    event = loop.get_event()
    process_event(event)

2. 实践

（1）异步结果不需要在前端返回

异步结果不需要在前端返回的例子:

# -*- coding: utf-8 -*-
import tornado
import tornado.web
import tornado.httpclient
import tornado.gen
import time


class AsyncResponseHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, *args, **kwargs):
        init_time = time.time()
        http_client = tornado.httpclient.AsyncHTTPClient()
        url = 'https://developer.github.com'
        http_client.fetch(url, self.on_response)
        spend_time = time.time() - init_time
        self.write('{}s'.format(spend_time))

    @tornado.gen.coroutine
    def on_response(self, response):
        print response.code


if __name__ == '__main__':
    app = tornado.web.Application([("/test", AsyncResponseHandler), ])
    app.listen(address='0.0.0.0', port=1234)
    tornado.ioloop.IOLoop.current().start()

这个例子中，主线程在发出请求urlhttps://developer.github.com之后，立即返回消耗时间，前端返回；然后网络请求完成后，cpu继续执行回调函数内部代码，直至回调函数结束。

（2）异步结果需要返回给前端

异步结果需要返回给前端的例子：

# -*- coding: utf-8 -*-
import tornado
import tornado.web
import tornado.httpclient
import tornado.gen
import time


class AsyncResponseHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, *args, **kwargs):
        init_time = time.time()
        http_client = tornado.httpclient.AsyncHTTPClient()
        url = 'https://developer.github.com'
        response = yield tornado.gen.Task(http_client.fetch, url)
        print(response.body)


if __name__ == '__main__':
    app = tornado.web.Application([("/test", AsyncResponseHandler), ])
    app.listen(address='0.0.0.0', port=1234)
    tornado.ioloop.IOLoop.current().start()

这个例子使用yield关键字获得异步请求url的返回结果：response。这个异步例子和同步模型的效果一样，虽然异步请求url，但是为了在主代码里获得response，还是需要等待请求成功。

（3）前端等待多个异步结果

前端等待多个异步结果的例子：

# -*- coding: utf-8 -*-
import tornado
import tornado.web
import tornado.httpclient
import tornado.gen
import time
import json


class AsyncResponseHandler(tornado.web.RequestHandler):
    @tornado.web.asynchronous
    @tornado.gen.coroutine
    def get(self, *args, **kwargs):
        init_time = time.time()
        http_client = tornado.httpclient.AsyncHTTPClient()
        results = []
        url = 'https://developer.github.com'
        tasks = [http_client.fetch(url) for _ in xrange(10)]  # 定义请求10次url的tasks
        waiter = tornado.gen.WaitIterator(*tasks)
        while not waiter.done():
            try:
                response = yield waiter.next()  # 每个task完成后，使用yield获得response
                results.append(response.code)
            except Exception as e:
                print e
                continue
        self.write(json.dumps(results))


if __name__ == '__main__':
    app = tornado.web.Application([
        ("/test", AsyncResponseHandler),
    ])
    app.listen(address='0.0.0.0', port=1234)
    tornado.ioloop.IOLoop.current().start()