Tornado Documentation, Release 6.1.dev1
Blocking
A function blocks when it waits for something to happen before returning. A function may block for many reasons:
network I/O, disk I/O, mutexes, etc. In fact, every function blocks, at least a little bit, while it is running and using
the CPU (for an extreme example that demonstrates why CPU blocking must be taken as seriously as other kinds of
blocking, consider password hashing functions like bcrypt, which by design use hundreds of milliseconds of CPU
time, far more than a typical network or disk access).
A function can be blocking in some respects and non-blocking in others. In the context of Tornado we generally talk
about blocking in the context of network I/O, although all kinds of blocking are to be minimized.
Asynchronous
An asynchronous function returns before it is finished, and generally causes some work to happen in the background
before triggering some future action in the application (as opposed to normal synchronous functions, which do every-
thing they are going to do before returning). There are many styles of asynchronous interfaces:
• Callback argument
• Return a placeholder (Future, Promise, Deferred)
• Deliver to a queue
• Callback registry (e.g. POSIX signals)
Regardless of which type of interface is used, asynchronous functions by definition interact differently with their
callers; there is no free way to make a synchronous function asynchronous in a way that is transparent to its callers
(systems like gevent use lightweight threads to offer performance comparable to asynchronous systems, but they do
not actually make things asynchronous).
Asynchronous operations in Tornado generally return placeholder objects (Futures), with the exception of some
low-level components like the IOLoop that use callbacks. Futures are usually transformed into their result with
the await or yield keywords.
Examples
Here is a sample synchronous function:
from tornado.httpclient import HTTPClient
def synchronous_fetch(url):
http_client = HTTPClient()
response = http_client.fetch(url)
return response.body
And here is the same function rewritten asynchronously as a native coroutine:
from tornado.httpclient import AsyncHTTPClient
async def asynchronous_fetch(url):
http_client = AsyncHTTPClient()
response = await http_client.fetch(url)
return response.body
Or for compatibility with older versions of Python, using the tornado.gen module:
14 Chapter 6. Documentation
我的内容管理
展开
