tornado.concurrent
— Work with threads and futures¶
Utilities for working with threads and Futures
.
Futures
are a pattern for concurrent programming introduced in
Python 3.2 in the concurrent.futures
package (this package has also
been backported to older versions of Python and can be installed with
pip install futures
). Tornado will use concurrent.futures.Future
if
it is available; otherwise it will use a compatible class defined in this
module.
-
class
tornado.concurrent.
Future
[source]¶ Placeholder for an asynchronous result.
A
Future
encapsulates the result of an asynchronous operation. In synchronous applicationsFutures
are used to wait for the result from a thread or process pool; in Tornado they are normally used withIOLoop.add_future
or by yielding them in agen.coroutine
.tornado.concurrent.Future
is similar toconcurrent.futures.Future
, but not thread-safe (and therefore faster for use with single-threaded event loops).In addition to
exception
andset_exception
, methodsexc_info
andset_exc_info
are supported to capture tracebacks in Python 2. The traceback is automatically available in Python 3, but in the Python 2 futures backport this information is discarded. This functionality was previously available in a separate classTracebackFuture
, which is now a deprecated alias for this class.Changed in version 4.0:
tornado.concurrent.Future
is always a thread-unsafeFuture
with support for theexc_info
methods. Previously it would be an alias for the thread-safeconcurrent.futures.Future
if that package was available and fall back to the thread-unsafe implementation if it was not.Changed in version 4.1: If a
Future
contains an error but that error is never observed (by callingresult()
,exception()
, orexc_info()
), a stack trace will be logged when theFuture
is garbage collected. This normally indicates an error in the application, but in cases where it results in undesired logging it may be necessary to suppress the logging by ensuring that the exception is observed:f.add_done_callback(lambda f: f.exception())
.
消费者方法¶
-
Future.
result
(timeout=None)[source]¶ If the operation succeeded, return its result. If it failed, re-raise its exception.
-
Future.
exception
(timeout=None)[source]¶ If the operation raised an exception, return the
Exception
object. Otherwise returns None.
-
Future.
exc_info
()[source]¶ Returns a tuple in the same format as
sys.exc_info
or None.New in version 4.0.
-
Future.
add_done_callback
(fn)[source]¶ Attaches the given callback to the
Future
.It will be invoked with the
Future
as its argument when the Future has finished running and its result is available. In Tornado consider usingIOLoop.add_future
instead of callingadd_done_callback
directly.
生产者方法¶
-
Future.
set_result
(result)[source]¶ Sets the result of a
Future
.It is undefined to call any of the
set
methods more than once on the same object.
-
Future.
set_exc_info
(exc_info)[source]¶ Sets the exception information of a
Future.
Preserves tracebacks on Python 2.
New in version 4.0.
-
tornado.concurrent.
run_on_executor
(fn)[source]¶ Decorator to run a synchronous method asynchronously on an executor.
The decorated method may be called with a
callback
keyword argument and returns a future.This decorator should be used only on methods of objects with attributes
executor
andio_loop
.
-
tornado.concurrent.
return_future
(f)[source]¶ Decorator to make a function that returns via callback return a
Future
.The wrapped function should take a
callback
keyword argument and invoke it with one argument when it has finished. To signal failure, the function can simply raise an exception (which will be captured by theStackContext
and passed along to theFuture
).From the caller’s perspective, the callback argument is optional. If one is given, it will be invoked when the function is complete with
Future.result()
as an argument. If the function fails, the callback will not be run and an exception will be raised into the surroundingStackContext
.If no callback is given, the caller should use the
Future
to wait for the function to complete (perhaps by yielding it in agen.engine
function, or passing it toIOLoop.add_future
).Usage:
@return_future def future_func(arg1, arg2, callback): # Do stuff (possibly asynchronous) callback(result) @gen.engine def caller(callback): yield future_func(arg1, arg2) callback()
Note that
@return_future
and@gen.engine
can be applied to the same function, provided@return_future
appears first. However, consider using@gen.coroutine
instead of this combination.