All asynchronous computation occurs within an executor, which is capable of spawning futures as tasks. This module provides several built-in executors, as well as tools for building your own.
Most of the time tasks should be executed on a thread pool. A small set of worker threads can handle a very large set of spawned tasks (which are much lighter weight than threads).
The simplest way to use a thread pool is to
run an initial task on it, which can
then spawn further tasks back onto the pool to complete its work:
use futures::executor::ThreadPool; // assumping `my_app: Future` ThreadPool::new().expect("Failed to create threadpool").run(my_app);
The call to
run will block the current
thread until the future defined by
my_app completes, and will return
the result of that future.
There are two ways to spawn a task:
Spawn onto a specific executor by calling its
Every task always has an associated default executor, which is usually the executor on which the task is running.
In addition to thread pools, it's possible to run a task (and the tasks
it spawns) entirely within a single thread via the
LocalPool executor. Aside from cutting down
on synchronization costs, this executor also makes it possible to
Send tasks, via
is best suited for running I/O-bound tasks that do relatively little
work between I/O operations.
There is also a convenience function,
block_on, for simply running a future to
completion on the current thread, while routing any spawned tasks
to a global thread pool.
An iterator which blocks on values from a stream until they become available.
Represents an executor context.
An error returned by
The type of future returned from the
A single-threaded task pool.
A future representing the completion of task spawning.
Provides the reason that an executor was unable to spawn.
A future representing the completion of task spawning, yielding a
A general-purpose thread pool for scheduling asynchronous tasks.
Thread pool configuration object.
A task executor.
Run a future to completion on the current thread.
Turn a stream into a blocking iterator.
Marks the current thread as being within the dynamic extent of an executor.
Spawn a task onto the default executor.
Spawn a task onto the default executor, yielding a