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:
#![feature(pin, arbitrary_self_types, futures_api)] 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 "default" spawner by calling the top-level
spawnfunction or pulling the spawner from the task context.
- Spawn onto a specific spawner by calling its
Every task always has an associated default spawner, 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
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.