Tornado——异步，websocket

模拟tornado两个socket请求

同步执行

按部就班的依次执行，知道上一个步骤执行完才执行下一步。

# coding:utf-8
import time

def long_io():      # 长io操作
    print("开始执行IO操作")
    time.sleep(2)
    print("完成IO操作")

def req_a():    # 模拟请求a
    print('开始处理请求req_a')
    long_io()       # 执行一个长io操作
    print('完成处理请求req_a')

def req_b():    # 模拟请求b
    print('开始处理请求req_b')
    print('完成处理请求req_b')

def main():     # 模拟tornado框架，处理两个请求
    req_a()
    req_b()

if __name__ == "__main__":
    main()

结果：

开始处理请求req_a
开始执行IO操作
完成IO操作
完成处理请求req_a
开始处理请求req_b
完成处理请求req_b

异步执行

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

1）引入线程和回调函数

# coding:utf-8
import time,threading   # 引入多线程

thread_list = []

def long_io(callback):      # 长io操作
    def fun(cb):
        print("开始执行IO操作")
        time.sleep(5)
        print("完成IO操作")
        cb("IO操作结束")     # 当线程结束时，执行回调函数

    threading.Thread(target=fun,args=(callback,)).start()    # 将长的io操作交个另一个线程来处理,此时long_io执行完毕（python多线程不用join）

def callback(ret):
    print(ret)

def req_a():    # 模拟请求a
    print('开始处理请求req_a')
    long_io(callback)       # 执行一个长io操作
    print('完成处理请求req_a')

def req_b():    # 模拟请求b
    print('开始处理请求req_b')
    print('完成处理请求req_b')

def main():     # 模拟tornado框架，处理两个请求
    req_a()
    req_b()

if __name__ == "__main__":
    main()

结果：

开始处理请求req_a
开始执行IO操作
完成处理请求req_a
开始处理请求req_b
完成处理请求req_b
完成IO操作
IO操作结束

2）引入协程

yield关键字：将函数/循环...变成生成器，使用__next__执行到下一个yield关键字的位置，使用send赋值并唤醒。

正常版本：

# coding:utf-8
import time,threading   # 引入多线程

thread_list = []

def long_io():      # 长io操作
    def fun():
        print("开始执行IO操作")
        time.sleep(5)
        print("完成IO操作")
        try:
            gen.send("============ IO操作结束 ============")     # 使用send返回结果并唤醒程序继续执行
        except:     # 捕获生成器完成迭代的异常，防止程序退出
            pass

    threading.Thread(target=fun).start()    # 将长的io操作交个另一个线程来处理,python多进程不用join

def req_a():    # 模拟请求a
    print('开始处理请求req_a')
    ret = yield long_io()       # 执行一个长io操作，接收结果
    print(ret)
    print('完成处理请求req_a')

def req_b():    # 模拟请求b
    print('开始处理请求req_b')
    print('完成处理请求req_b')

def main():     # 模拟tornado框架，处理两个请求
    global gen
    gen = req_a()   # 初始化生成器
    gen.__next__()    # 执行到第一个yield位置

    req_b()

if __name__ == "__main__":
    main()

结果：

开始处理请求req_a
开始执行IO操作
开始处理请求req_b
完成处理请求req_b
完成IO操作
============ IO操作结束 ============
完成处理请求req_a

装饰器版本：

# coding:utf-8
import time,threading   # 引入多线程

thread_list = []

def long_io():      # 长io操作
    def fun():
        print("开始执行IO操作")
        time.sleep(5)
        print("完成IO操作")
        try:
            gen.send("============ IO操作结束 ============")     # 使用send返回结果并唤醒程序继续执行
        except:     # 捕获生成器完成迭代的异常，防止程序退出
            pass

    threading.Thread(target=fun).start()    # 将长的io操作交个另一个线程来处理,python多进程不用join

def gen_coroutine(f):
    def inner(*args,**kwargs):
        global gen
        gen = f()  # 执行req_a，初始化生成器
        gen.__next__()  # 执行到第一个yield位置
    return inner

@gen_coroutine
def req_a():    # 模拟请求a
    print('开始处理请求req_a')
    ret = yield long_io()       # 执行一个长io操作，接收结果
    print(ret)
    print('完成处理请求req_a')

def req_b():    # 模拟请求b
    print('开始处理请求req_b')
    print('完成处理请求req_b')

def main():     # 模拟tornado框架，处理两个请求
    req_a()　　# 下面不修改
    req_b()

if __name__ == "__main__":
    main()

结果：

开始处理请求req_a
开始执行IO操作
开始处理请求req_b
完成处理请求req_b
完成IO操作
============ IO操作结束 ============
完成处理请求req_a

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

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

Tornado的异步

因为epoll主要是用来解决网络IO的并发问题，所以Tornado的异步编程也主要体现在网络IO的异步上，即异步Web请求。

将每个建立起来的socket送入epoll池中监听，当有请求来了的时候，epoll会捕捉信号并将生成器，断点...全部打包给IOLoop，让IOLoop来进行调度。

经过路由映射交给视图函数处理，当遇到堵塞的时候会将生成器，断点...全部打包还给IOLoop，等待下一次调度。

tornado.httpclient.AsyncHTTPClient

Tornado提供了一个异步Web请求客户端tornado.httpclient.AsyncHTTPClient用来进行异步Web请求。

fetch(request, callback=None)

用于执行一个web请求request，并异步返回一个tornado.httpclient.HTTPResponse响应。

request可以是一个url，也可以是一个tornado.httpclient.HTTPRequest对象。如果是url，fetch会自己构造一个HTTPRequest对象。

HTTPRequest

HTTP请求类，HTTPRequest的构造函数可以接收众多构造参数，最常用的如下：

• url (string) – 要访问的url，此参数必传，除此之外均为可选参数
• method (string) – HTTP访问方式，如“GET”或“POST”，默认为GET方式
• headers (HTTPHeaders or dict) – 附加的HTTP协议头
• body – HTTP请求的请求体

HTTPResponse

HTTP响应类，其常用属性如下：

• code: HTTP状态码，如 200 或 404
• reason: 状态码描述信息
• body: 响应体字符串
• error: 异常（可有可无）

装饰器（tornado.web.asynchronous）

此装饰器用于回调形式的异步方法，并且应该仅用于HTTP的方法上（如get、post等）。

此装饰器不会让被装饰的方法变为异步，而只是告诉框架被装饰的方法是异步的，当方法返回时响应尚未完成。只有在request handler调用了finish方法后，才会结束本次请求处理，发送响应。

不带此装饰器的请求在get、post等方法返回时自动完成结束请求处理。

callback异步：

# coding:utf-8
import tornado.web
import tornado.ioloop
import tornado.httpserver
import tornado.options
import json

from tornado.web import url,RequestHandler
from tornado.options import define,options
from tornado.httpclient import AsyncHTTPClient      # 引入异步Web请求客户端

tornado.options.define("port",default=8001,type=int,help="给个端口号呗")

class IndexHandler(RequestHandler):
    @tornado.web.asynchronous  # 不关闭连接，也不发送响应（因为在get，post方法执行后会执行on_finish方法，会关闭管道）
    def get(self):
        http = AsyncHTTPClient()　　# 实例化异步客户端
        http.fetch("http://int.dpool.sina.com.cn/iplookup/iplookup.php?format=json&ip=14.130.112.24",callback=self.on_response)　　# 发送一个http请求

    def on_response(self, response):
        if response.error:
            self.send_error(500)
        else:
            data = json.loads(response.body)　　# 获取响应体
            if 1 == data["ret"]:
                self.write(u"国家：%s 省份: %s 城市: %s" % (data["country"], data["province"], data["city"]))
            else:
                self.write("查询IP信息错误")
        self.finish()       # 发送响应信息，结束请求处理

if __name__ == "__main__":
    tornado.options.parse_command_line()
    app = tornado.web.Application(
        [
        (r"/",IndexHandler),
        ],
        debug = True
    )

    http_server = tornado.httpserver.HTTPServer(app)    # 创建httpserver实例
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

结果：

国家：中国 省份: 北京 城市: 北京

协程异步：

# coding:utf-8
import tornado.web
import tornado.ioloop
import tornado.httpserver
import tornado.options
import json

from tornado.web import url,RequestHandler
from tornado.options import define,options
from tornado.httpclient import AsyncHTTPClient      # 引入异步Web请求客户端
import tornado.gen

tornado.options.define("port",default=8001,type=int,help="给个端口号呗")

class IndexHandler(RequestHandler):
    class IndexHandler(tornado.web.RequestHandler):
        @tornado.gen.coroutine
        def get(self):
            http = AsyncHTTPClient()
            response = yield http.fetch(
                "http://int.dpool.sina.com.cn/iplookup/iplookup.php?format=json&ip=14.130.112.24")
            if response.error:
                self.send_error(500)
            else:
                data = json.loads(response.body)
                if 1 == data["ret"]:
                    self.write(u"国家：%s 省份: %s 城市: %s" % (data["country"], data["province"], data["city"]))
                else:
                    self.write("查询IP信息错误")

if __name__ == "__main__":
    tornado.options.parse_command_line()
    app = tornado.web.Application(
        [
        (r"/",IndexHandler),
        ],
        debug = True
    )

    http_server = tornado.httpserver.HTTPServer(app)    # 创建httpserver实例
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

也可以将异步Web请求单独出来：

class IndexHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        rep = yield self.get_ip_info("14.130.112.24")
        if 1 == rep["ret"]:
            self.write(u"国家：%s 省份: %s 城市: %s" % (rep["country"], rep["province"], rep["city"]))
        else:
            self.write("查询IP信息错误")

    @tornado.gen.coroutine
    def get_ip_info(self, ip):
        http = tornado.httpclient.AsyncHTTPClient()
        response = yield http.fetch("http://int.dpool.sina.com.cn/iplookup/iplookup.php?format=json&ip=" + ip)
        if response.error:
            rep = {"ret:0"}
        else:
            rep = json.loads(response.body)
        return(rep)  # 此处需要注意,python2中使用raise tornado.gen.Return

代码中我们需要注意的地方是get_ip_info返回值的方式，在python 2中，使用了yield的生成器可以使用不返回任何值的return，但不能return value，因此Tornado为我们封装了用于在生成器中返回值的特殊异常tornado.gen.Return，并用raise来返回此返回值。

并行协程：

Tornado可以同时执行多个异步，并发的异步可以使用列表或字典，如下：

class IndexHandler(tornado.web.RequestHandler):
    @tornado.gen.coroutine
    def get(self):
        ips = ["14.130.112.24",
            "15.130.112.24",
            "16.130.112.24",
            "17.130.112.24"]
        rep1, rep2 = yield [self.get_ip_info(ips[0]), self.get_ip_info(ips[1])]
        rep34_dict = yield dict(rep3=self.get_ip_info(ips[2]), rep4=self.get_ip_info(ips[3]))
        self.write_response(ips[0], rep1) 
        self.write_response(ips[1], rep2) 
        self.write_response(ips[2], rep34_dict['rep3']) 
        self.write_response(ips[3], rep34_dict['rep4']) 

    def write_response(self, ip, response):
        self.write(ip) 
        self.write(":<br/>") 
        if 1 == response["ret"]:
            self.write(u"国家：%s 省份: %s 城市: %s<br/>" % (response["country"], response["province"], response["city"]))
        else:
            self.write("查询IP信息错误<br/>")

    @tornado.gen.coroutine
    def get_ip_info(self, ip):
        http = tornado.httpclient.AsyncHTTPClient()
        response = yield http.fetch("http://int.dpool.sina.com.cn/iplookup/iplookup.php?format=json&ip=" + ip)
        if response.error:
            rep = {"ret:1"}
        else:
            rep = json.loads(response.body)
        raise tornado.gen.Return(rep)

关于数据库的异步说明

网站基本都会有数据库操作，而Tornado是单线程的，这意味着如果数据库查询返回过慢，整个服务器响应会被堵塞。

数据库查询，实质上也是远程的网络调用；理想情况下，是将这些操作也封装成为异步的；但Tornado对此并没有提供任何支持。

这是Tornado的设计，而不是缺陷。

一个系统，要满足高流量；是必须解决数据库查询速度问题的！

数据库若存在查询性能问题，整个系统无论如何优化，数据库都会是瓶颈，拖慢整个系统！

异步并不能从本质上提到系统的性能；它仅仅是避免多余的网络响应等待，以及切换线程的CPU耗费。

如果数据库查询响应太慢，需要解决的是数据库的性能问题；而不是调用数据库的前端Web应用。

对于实时返回的数据查询，理想情况下需要确保所有数据都在内存中，数据库硬盘IO应该为0；这样的查询才能足够快；而如果数据库查询足够快，那么前端web应用也就无将数据查询封装为异步的必要。

就算是使用协程，异步程序对于同步程序始终还是会提高复杂性；需要衡量的是处理这些额外复杂性是否值得。

如果后端有查询实在是太慢，无法绕过，Tornaod的建议是将这些查询在后端封装独立封装成为HTTP接口，然后使用Tornado内置的异步HTTP客户端进行调用。

websocket

WebSocket是HTML5规范中新提出的客户端-服务器通讯协议，协议本身使用新的ws://URL格式。

WebSocket 是独立的、创建在 TCP 上的协议，和 HTTP 的唯一关联是使用 HTTP 协议的101状态码进行协议切换，使用的 TCP 端口是80，可以用于绕过大多数防火墙的限制。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端直接向客户端推送数据而不需要客户端进行请求，两者之间可以创建持久性的连接，并允许数据进行双向传送。

目前常见的浏览器如 Chrome、IE、Firefox、Safari、Opera 等都支持 WebSocket，同时需要服务端程序支持 WebSocket。

1. Tornado的WebSocket模块

Tornado提供支持WebSocket的模块是tornado.websocket，其中提供了一个WebSocketHandler类用来处理通讯。

WebSocketHandler.open()

当一个WebSocket连接建立后被调用。

WebSocketHandler.on_message(message)

当客户端发送消息message过来时被调用，注意此方法必须被重写。

WebSocketHandler.on_close()

当WebSocket连接关闭后被调用。

WebSocketHandler.write_message(message, binary=False)

向客户端发送消息messagea，message可以是字符串或字典（字典会被转为json字符串）。若binary为False，则message以utf8编码发送；二进制模式（binary=True）时，可发送任何字节码。

WebSocketHandler.close()

关闭WebSocket连接。

WebSocketHandler.check_origin(origin)

判断源origin，对于符合条件（返回判断结果为True）的请求源origin允许其连接，否则返回403。可以重写此方法来解决WebSocket的跨域请求（如始终return True）。

2. 前端JavaScript编写

在前端JS中使用WebSocket与服务器通讯的常用方法如下：

var ws = new WebSocket("ws://127.0.0.1:8888/websocket"); // 新建一个ws连接
ws.onopen = function() {  // 连接建立好后的回调
   ws.send("Hello, world");  // 向建立的连接发送消息
};
ws.onmessage = function (evt) {  // 收到服务器发送的消息后执行的回调
   alert(evt.data);  // 接收的消息内容在事件参数evt的data属性中
};

在线聊天室的小Demo

# coding:utf-8

import tornado.web
import tornado.ioloop
import tornado.httpserver
import tornado.options
import os
import datetime

from tornado.web import RequestHandler
from tornado.options import define, options
from tornado.websocket import WebSocketHandler

define("port", default=8000, type=int)

class IndexHandler(RequestHandler):
    def get(self):
        self.render("index.html")

class ChatHandler(WebSocketHandler):

    users = set()  # 用来存放在线用户的容器

    def open(self):
        self.users.add(self)  # 建立连接后添加用户到容器中
        for u in self.users:  # 向已在线用户发送消息
            u.write_message(u"[%s]-[%s]-进入聊天室" % (self.request.remote_ip, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))

    def on_message(self, message):
        for u in self.users:  # 向在线用户广播消息
            u.write_message(u"[%s]-[%s]-说：%s" % (self.request.remote_ip, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), message))

    def on_close(self):
        self.users.remove(self) # 用户关闭连接后从容器中移除用户
        for u in self.users:
            u.write_message(u"[%s]-[%s]-离开聊天室" % (self.request.remote_ip, datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))

    def check_origin(self, origin):
        return True  # 允许WebSocket的跨域请求

if __name__ == '__main__':
    tornado.options.parse_command_line()
    app = tornado.web.Application([
            (r"/", IndexHandler),
            (r"/chat", ChatHandler),
        ],
        static_path = os.path.join(os.path.dirname(__file__), "static"),
        template_path = os.path.join(os.path.dirname(__file__), "template"),
        debug = True
        )
    http_server = tornado.httpserver.HTTPServer(app)
    http_server.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>聊天室</title>
</head>
<body>
    <div id="contents" style="height:500px;overflow:auto;"></div>
    <div>
        <textarea id="msg"></textarea>
        <a href="javascript:;" onclick="sendMsg()">发送</a>
    </div>
    <script src="{{static_url('js/jquery.min.js')}}"></script>
    <script type="text/javascript">
        var ws = new WebSocket("ws://192.168.114.177:8000/chat");
        ws.onmessage = function(e) {
            $("#contents").append("<p>" + e.data + "</p>");
        }
        function sendMsg() {
            var msg = $("#msg").val();
            ws.send(msg);
            $("#msg").val("");
        }
    </script>
</body>
</html>