Task execution utilities.
In the Tokio execution model, futures are lazy. When a future is created, no work is performed. In order for the work defined by the future to happen, the future must be submitted to an executor. A future that is submitted to an executor is called a "task".
The executor is responsible for ensuring that
called whenever the task is notified. Notification happens when the
internal state of a task transitions from "not ready" to ready. For
example, a socket might have received data and a call to
read will now be
able to succeed.
The specific strategy used to manage the tasks is left up to the
executor. There are two main flavors of executors: single-threaded and
multi-threaded. Tokio provides implementation for both of these in the
This module provides the
Executor trait (re-exported from
tokio-executor), which describes the API that all executors must
spawn function is provided that allows spawning futures onto the
default executor (tracked via a thread-local variable) without referencing a
handle. It is expected that all executors will set a value for the default
executor. This value will often be set to the executor itself, but it is
possible that the default executor might be set to a different executor.
For example, a single threaded executor might set the default executor to a
thread pool instead of itself, allowing futures to spawn new tasks onto the
thread pool when those tasks are
Executes futures on the default executor for the current execution context.
Return value from the
Errors returned by
A value that executes futures.
A value that spawns futures of a specific type.
Spawns a future on the default executor.