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.
This module is only available when the
std feature of this
library is activated, and it is activated by default.
Using a thread pool (M:N task scheduling)
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; // assuming `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.
Spawning additional tasks
Tasks can be spawned onto a spawner by calling its
spawn_obj method directly.
In the case of
can be used instead.
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
LocalPool 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
A single-threaded task pool for polling futures to completion.
A general-purpose thread pool for scheduling tasks that poll futures to completion.
Thread pool configuration object.
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.