异步非阻塞
理解 Tornado 架构的关键在于理解 异步非阻塞 I/O。
（图片来源网络，侵删）
- 阻塞 I/O (Blocking I/O)：传统的同步模型，当一个请求需要进行磁盘读写或网络请求时，整个线程会“阻塞”等待，直到操作完成，在这期间，该线程无法处理任何其他请求，对于高并发场景，这需要为每个连接创建一个线程，导致线程数量剧增，内存消耗巨大,上下文切换开销也很大。
- 非阻塞 I/O (Non-blocking I/O)：线程发起一个 I/O 操作后，不会被阻塞，而是立即返回，当 I/O 操作完成后，操作系统会通知应用程序，应用程序需要一种机制来“轮询”或“监听”这些已完成的事件。
- 异步：指的是在非阻塞的基础上，使用回调、Future 或协程等方式，让程序在等待 I/O 完成的这段时间里，可以去执行其他任务,而不是空等。
Tornado 的选择：Tornado 采用 单线程 + 异步非阻塞 的模型，它使用一个 I/O 多路复用技术（在 Linux 上是 epoll，在 macOS/Windows 上是 kqueue 或 select）来高效地管理成千上万个并发连接，一个主线程（或少量工作线程）通过事件循环来调度所有任务的执行,从而实现高并发和高性能。
Tornado 架构的核心组件
Tornado 的架构可以看作是由几个关键组件协同工作的结果。
IOLoop - 事件循环的引擎
IOLoop 是 Tornado 架构的心脏,是整个异步模型的调度中心。
- 作用：它是一个单线程的事件循环，负责监听和管理所有 I/O 事件（如新连接、数据可读、数据可写等）。
- 工作方式：
IOLoop启动后,会进入一个无限循环。- 它会向操作系统注册所有感兴趣的套接字和文件描述符。
- 然后调用
epoll_wait(或类似函数) 让内核等待这些事件的发生。 - 当某个事件发生时（有新的 HTTP 请求到达），内核会通知
IOLoop。 IOLoop从等待中返回,并调用与该事件关联的回调函数来处理它。- 处理完一个事件后，
IOLoop会继续等待下一个事件。
- 关键点：
IOLoop本身是单线程的，因此所有在IOLoop上运行的代码都必须是非阻塞的，否则会阻塞整个事件循环,导致服务器无响应。
HTTPServer - 网络层
HTTPServer 负责底层的网络通信。
（图片来源网络，侵删）
- 作用：在指定的端口上监听 TCP 连接，接收原始的 HTTP 请求，并将其解析为
HTTPRequest对象。 - 与
IOLoop的关系：HTTPServer在启动时会将其监听套接字注册到IOLoop上，当有新的连接到达时，IOLoop会通知HTTPServer，HTTPServer再将连接分发给对应的处理器。
RequestHandler - 应用逻辑层
RequestHandler 是开发者最常接触的组件,用于处理具体的业务逻辑。
- 作用：开发者通过继承
tornado.web.RequestHandler来创建自己的处理器，每个处理器类通常对应一个 URL 路径（通过tornado.web.Application的handlers列表配置）。 - 核心方法：
get(self, *args, **kwargs): 处理 HTTP GET 请求。post(self, *args, **kwargs): 处理 HTTP POST 请求。initialize(): 在处理器实例化时被调用,用于初始化。write(chunk): 向客户端写入响应体。finish(): 完成响应,结束本次请求。
- 执行流程：
- 当
IOLoop接收到一个完整的 HTTP 请求后，会找到对应的RequestHandler实例。 IOLoop会调用该实例的HTTP方法（如get或post）。- 这个方法中的所有代码都应该尽快执行完毕，因为它是事件循环中的一个回调，如果遇到 I/O 操作（如数据库查询、调用其他 API），绝对不能使用同步方式，而必须使用 Tornado 提供的异步方式（如
tornado.gen.coroutine、async/await或Future），并将控制权交还给IOLoop,以便处理其他请求。
- 当
Application - 应用总管
Application 是 Tornado 应用的入口和配置中心。
-
作用：它将所有的
RequestHandler、URL 路由规则、模板路径、静态文件路径等配置整合在一起,形成一个完整的应用实例。 -
创建与启动：
（图片来源网络，侵删）# 1. 创建 Application 实例，配置路由和处理器 app = tornado.web.Application([ (r"/", MainHandler), (r"/story/([0-9]+)", StoryHandler), ]) # 2. 创建 HTTPServer 实例，并与 Application 关联 server = tornado.httpserver.HTTPServer(app) # 3. 将 server 绑定到 IOLoop 并启动 server.listen(8888) tornado.ioloop.IOLoop.current().start()
异步工具 (Future, gen.coroutine, async/await)
为了在异步框架中优雅地处理 I/O 操作，Tornado 提供了强大的异步工具。
Future: 代表一个未来会结果的操作，当一个异步操作开始时，会立即返回一个Future对象，你可以通过future.result()来获取结果，但这样会阻塞，正确的做法是使用future.add_done_callback()来注册一个回调函数,当结果就绪时自动调用。@tornado.gen.coroutine装饰器: 这是 Tornado 早期实现异步的“利器”，它将一个生成器函数包装成一个协程，在函数内部，可以使用yield关键字来等待一个Future完成，而不会阻塞整个事件循环。class AsyncHandler(tornado.web.RequestHandler): @tornado.gen.coroutine def get(self): # 模拟一个耗时的异步操作 # yield 会暂停这个协程，但 IOLoop 可以去处理其他请求 result = yield some_async_function() self.write("Async result: " + result)async/await: Python 3.5+ 引入的官方异步语法，现在已经成为 Tornado 的首选，它比@gen.coroutine更简洁、更易读，原理与yield类似。class AsyncHandler(tornado.web.RequestHandler): async def get(self): result = await some_async_function() self.write("Async result: " + result)
架构流程图与示例
架构流程图
+----------------+ +----------------+ +----------------+
| Client | | Client | | Client |
+----------------+ +----------------+ +----------------+
| | |
| (1) HTTP Request | (1) HTTP Request | (1) HTTP Request
| | |
V V V
+----------------+ +----------------+ +----------------+
| HTTPServer | | HTTPServer | | HTTPServer |
| (监听端口) | | (监听端口) | | (监听端口) |
+----------------+ +----------------+ +----------------+
| | |
| (2) 注册到 IOLoop | (2) 注册到 IOLoop | (2) 注册到 IOLoop
| | |
V V V
+---------------------------------------------------------------+
| IOLoop (事件循环) |
| - 使用 epoll/kqueue 监听所有 I/O 事件 |
| - 当事件就绪，调用对应的回调函数 |
| |
| +---------------------------+ |
| | 事件就绪，调用 Handler | <---------------------------------+
| +---------------------------+ |
| |
| V V |
| +----------------+ +----------------+ |
| | RequestHandler | | RequestHandler | |
| | (处理 GET/POST) | | (处理 GET/POST) | |
| +----------------+ +----------------+ |
| | | |
| (3) 执行同步代码 (快) (3) 执行同步代码 (快) |
| | | |
| V V |
| (4) 遇到异步 I/O (如 DB) (4) 遇到异步 I/O (如 API)|
| | | |
| +---------------------------+ +----------------+ |
| | yield/await Future | | yield/await | |
| +---------------------------+ | Future | |
| | +----------------+ |
| V | |
| (5) 暂停协程，将 Future 注册到 IOLoop | |
| | | |
| +--------------------------------------------+ |
| |
| IOLoop 继续运行，处理其他客户端的请求... |
| |
| +---------------------------------------------------------+ |
| | 当异步操作完成，IOLoop 被唤醒，继续执行暂停的协程 | |
| +---------------------------------------------------------+ |
| | | |
| V V |
| (6) 获取结果，继续执行 Handler |
| | | |
| (7) self.write() / self.finish() | |
| | | |
| V V |
+---------------------------------------------------------------+
| | |
| (8) HTTP Response | (8) HTTP Response | (8) HTTP Response
V V V
+----------------+ +----------------+ +----------------+
| Client | | Client | | Client |
+----------------+ +----------------+ +----------------+代码示例
下面是一个简单的 Tornado 应用,展示了其异步特性。
import tornado.ioloop
import tornado.web
import tornado.httpclient
import time
import asyncio
# 模拟一个异步的数据库查询或外部 API 调用
# 在真实场景中，这可能是数据库驱动或 HTTP 客户端的异步调用
async def fetch_data_from_db():
print("[DB] 开始获取数据...")
# 模拟 2 秒的网络延迟
await asyncio.sleep(2)
print("[DB] 数据获取完成!")
return {"user_id": 123, "name": "Tornado User"}
class MainHandler(tornado.web.RequestHandler):
async def get(self):
start_time = time.time()
# 1. 同步操作，非常快
self.write("Hello, Tornado! 开始获取数据...<br>")
# 2. 异步操作：遇到 I/O，使用 await 暂停当前协程
# IOLoop 会去处理其他请求，不会阻塞在这里
data = await fetch_data_from_db()
# 3. 异步操作完成后，协程恢复执行
self.write(f"<br>数据获取成功: {data}<br>")
end_time = time.time()
self.write(f"<br>总耗时: {end_time - start_time:.2f} 秒")
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
print("Server is running on http://localhost:8888")
tornado.ioloop.IOLoop.current().start()
运行这个例子并并发访问 http://localhost:8888，你会发现：
即使一个请求需要 2 秒等待，服务器依然可以立即响应其他新来的请求，每个请求的耗时大约是 2 秒，而不是 2 秒 * N（N 是并发请求数），这完美地体现了 Tornado 的高并发能力。
架构优缺点
优点
- 高并发、高性能：单线程事件循环模型使其在处理大量长连接（如 WebSocket、Comet）和 I/O 密集型任务时性能卓越。
- 实时性：专为实时 Web 应用设计，对 WebSocket 和长连接有很好的支持。
- 自成一体的框架：Web 框架、HTTP 客户端/服务器、模板引擎等都是 Tornado 的一部分，集成度高,开箱即用。
- Python 原生异步支持：对 Python 3.5+ 的
async/await语法支持良好,异步代码清晰易写。
缺点
- CPU 密集型任务处理不佳：由于是单线程模型，任何 CPU 密集型计算（如复杂的数据处理、加密）都会阻塞整个事件循环，导致所有请求响应变慢，如果必须处理这类任务，需要将任务放到单独的进程池中（Tornado 提供了
tornado.process）。 - 生态系统相对较小：相比 Flask/Django，Tornado 的社区和第三方库较少，很多为 WSGI 生态设计的库无法直接在 Tornado 的异步环境中使用。
- 学习曲线：对于习惯了同步编程的开发者来说,理解异步非阻塞模型需要一定的学习和适应时间。
- 全局锁问题：在单线程模型中，所有共享状态都需要注意线程安全问题，虽然 Python 的 GIL 在这里影响不同,但逻辑上的竞态条件依然存在。
Tornado 的架构是围绕 单线程事件循环 这一核心思想构建的，它通过 IOLoop 高效调度，利用 HTTPServer 处理网络层，并通过异步的 RequestHandler 来执行业务逻辑，这种架构使其在需要处理海量并发连接的实时应用场景中表现出色，但在处理 CPU 密集型任务时则显得力不从心，选择 Tornado,意味着选择拥抱其异步哲学。
