tornado 框架 —— 基本使用与异步非阻塞
tornado 框架
基本使用和模板渲染
# tornado
# 微框架，高性能，异步支持
# 轮子比较少
# 应用场景
# 构建微服务，不适合复杂的 CMS 内容管理系统
# 网站或App后端微服务
# introduction to tornado
import os
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self): # restful api
self.write("Hello World")
class TemplateHandler(tornado.web.RequestHandler):
def get(self):
# self.write("<h1>hello world<h1>") # 生效的
# 模板渲染
self.render("base.html")
class ErrorHandler(tornado.web.RequestHandler):
def get(self):
# 传递模板变量
self.render("500.html", user="伞兵")
def make_server():
return tornado.web.Application([
(r"/", MainHandler),
(r"/t", TemplateHandler),
(r"/500", ErrorHandler)
],
template_path=os.path.dirname(__file__)
)
if __name__ == "__main__":
server = make_server()
server.listen(8000)
tornado.ioloop.IOLoop.current().start()
# tornado 模块
# tornado.web Application 和 RequestHandler 处理 http 请求
# tornado.template 模板渲染
# tornadoo.routing 处理路由
# tornado.ioloop 事件循环
# 不断的循环，轮询。select, epoll, kqueue(unix)
# tornado.iostream 非阻塞 socket 封装
# tornado.tcpserver 和 tornado.tcpclient
# tornado.gen 协程模块
# tornado.locks/tornado.queues 同步、协程队列模块
base.html
<h1>hello tornado template</h1>
500.html
<h1>{{ user }}</h1>你好，出错了
阻塞与非阻塞服务
import time
import datetime
import tornado.gen
import tornado.httpserver
import tornado.ioloop
import tornado.web
# 异步服务器
# 同步服务器一次处理一个请求，一个socket链接
# 异步服务器 系统调用 epoll，select，同时监听多个socket客户端链接，事件循环，当socket上有可读或可写的事件的时候，才会去处理它。
# 单线程实现并发，协程
class SleepHandler(tornado.web.RequestHandler):
def get(self):
# 这样写，两个请求串行执行的，即两个请求的返回时间差 5 秒
time.sleep(5)
self.write("{}".format(str(datetime.datetime.now())))
class SleepAsyncHandler(tornado.web.RequestHandler):
# 两个请求异步执行，即两个请求的返回时间基本相同，协程并发处理
# 不要用同一个浏览器验证，是浏览器原因
@tornado.gen.coroutine
def get(self):
yield tornado.gen.sleep(5)
self.write("async {}".format(str(datetime.datetime.now())))
if __name__ == "__main__":
# debug = True 修改后会重启
server = tornado.web.Application([
(r"/sleep", SleepHandler),
(r"/async_sleep", SleepAsyncHandler)
],
debug=True
)
http_server = tornado.httpserver.HTTPServer(server)
http_server.listen(8000)
tornado.ioloop.IOLoop.instance().start()
异步请求客户端
import time
import tornado.gen
import tornado.httpclient
import tornado.ioloop
from tornado import gen
N = 10
URL = 'http://localhost:8000/async_sleep'
# 异步并发请求，客户端请求
@gen.coroutine
def main():
http_client = tornado.httpclient.AsyncHTTPClient()
responses = yield [
http_client.fetch(URL) for i in range(N)
]
t1 = time.time()
tornado.ioloop.IOLoop.current().run_sync(main)
print("async", time.time() - t1) # async 5.221109390258789 10次请求，一共花了一次的时间 5 秒左右
restful 用户微服务
# restful 用户管理微服务
# model.py
class UserModel:
users = {
1 : {'name':'wl','password':123},
2 : {'name':'wl','password':123},
3 : {'name':'wl','password':123},
}
@classmethod
def get(cls, id):
return cls.users.get(id)
@classmethod
def get_all(cls):
# 生成器不能序列化
return list(cls.users.values())
@classmethod
def create_update(cls, id, data):
if isinstance(data, dict):
cls.users[id] = data
return True
@classmethod
def delete(cls, id):
try:
del cls.users[id]
return True
except Exception as e:
print('delete')
print(e)
# handlers.py
import tornado.web
from tornado.escape import json_encode, json_decode
class UserListHandler(tornado.web.RequestHandler):
def get(self):
users = UserModel.get_all()
self.write(json_encode(users))
def post(self):
# get_argument('name')
data_dict = json_decode(self.request.body)
print(data_dict)
id = data_dict.get('id')
data = data_dict.get('data')
if id is not None and data is not None:
is_ok = UserModel.create_update(id, data)
if is_ok:
self.write('create or updata success')
return
self.write('create or updata fail')
class UserHandler(tornado.web.RequestHandler):
def get(self,id):
user = UserModel.get(int(id))
if user:
self.write(json_encode(user))
return
self.write('get {} data fail'.format(id))
def delete(self,id):
print(id,type(id))
is_ok = UserModel.delete(int(id))
if is_ok:
self.write('delete success')
return
self.write('delete fail')
# app.py
HANDLERS = [
(r"/api/users", UserListHandler),
(r"/api/users/(\d+)", UserHandler)
]
def run():
app = tornado.web.Application(
HANDLERS,
debug=True
)
http_server = tornado.httpserver.HTTPServer(app)
port = 8000
http_server.listen(port)
print("server start on port:{}".format(port))
tornado.ioloop.IOLoop.instance().start()
if __name__ == "__main__":
run()
同步、异步、阻塞、非阻塞
同步与异步（线程间调用）
Copy同步与异步是对应于调用者与被调用者，它们是线程之间的关系，两个线程之间要么是同步的，要么是异步的
同步操作时，调用者需要等待被调用者返回结果，才会进行下一步操作
而异步则相反，调用者不需要等待被调用者返回调用，即可进行下一步操作，被调用者通常依靠事件、回调等机制来通知调用者结果
阻塞与非阻塞（线程内调用）
Copy阻塞与非阻塞是对同一个线程来说的，在某个时刻，线程要么处于阻塞，要么处于非阻塞
阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态：
阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。
同步与异步调用/线程/通信
Copy同步就是两种东西通过一种机制实现步调一致，异步是两种东西不必步调一致
一、同步调用与异步调用：
在用在调用场景中，无非是对调用结果的不同处理。
同步调用就是调用一但返回，就能知道结果，而异步是返回时不一定知道结果，还得通过其他机制来获知结果，如：
a. 状态 b. 通知 c. 回调函数
二、同步线程与异步线程：
同步线程：即两个线程步调要一致，其中一个线程可能要阻塞等待另外一个线程的运行，要相互协商。快的阻塞一下等到慢的步调一致。
异步线程：步调不用一致，各自按各自的步调运行，不受另一个线程的影响。
三、同步通信与异步通信：
同步和异步是指：发送方和接收方是否协调步调一致
同步通信是指：发送方和接收方通过一定机制，实现收发步调协调。
如：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式
异步通信是指：发送方的发送不管接收方的接收状态。
如：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。
阻塞可以是实现同步的一种手段！例如两个东西需要同步，一旦出现不同步情况，我就阻塞快的一方，使双方达到同步。
同步是两个对象之间的关系，而阻塞是一个对象的状态。
POSIX对这两个术语的定义：
同步I/O操作：导致请求进程阻塞，直到I/O操作完成；
异步I/O操作：不导致请求进程阻塞。
综上，tornado 异步非阻塞
同步异步是两个线程之间的关系，阻塞非阻塞是一个线程当前的状态。
同一个浏览器访问一个服务器服务，因为浏览器必须等待结果，所以 是同步调用。tornado 异步客户端调用一个服务器服务不需要等待结果，就可以进行下一个请求，所以 是异步调用。
tornado服务在使用协程之前，一个线程只能一次处理一个请求，是阻塞的。使用协程装饰器，一个线程可以同时处理多个请求了，是非阻塞的。
