Struct futures_executor::LocalPool
source · pub struct LocalPool { /* private fields */ }
Expand description
A single-threaded task pool for polling futures to completion.
This executor allows you to multiplex any number of tasks onto a single thread. It’s appropriate to poll strictly I/O-bound futures that do very little work in between I/O actions.
To get a handle to the pool that implements
Spawn
, use the
spawner()
method. Because the executor is
single-threaded, it supports a special form of task spawning for non-Send
futures, via spawn_local_obj
.
Implementations§
source§impl LocalPool
impl LocalPool
sourcepub fn spawner(&self) -> LocalSpawner
pub fn spawner(&self) -> LocalSpawner
Get a clonable handle to the pool as a [Spawn
].
sourcepub fn run(&mut self)
pub fn run(&mut self)
Run all tasks in the pool to completion.
use futures::executor::LocalPool;
let mut pool = LocalPool::new();
// ... spawn some initial tasks using `spawn.spawn()` or `spawn.spawn_local()`
// run *all* tasks in the pool to completion, including any newly-spawned ones.
pool.run();
The function will block the calling thread until all tasks in the pool are complete, including any spawned while running existing tasks.
sourcepub fn run_until<F: Future>(&mut self, future: F) -> F::Output
pub fn run_until<F: Future>(&mut self, future: F) -> F::Output
Runs all the tasks in the pool until the given future completes.
use futures::executor::LocalPool;
let mut pool = LocalPool::new();
// run tasks in the pool until `my_app` completes
pool.run_until(my_app);
The function will block the calling thread only until the future f
completes; there may still be incomplete tasks in the pool, which will
be inert after the call completes, but can continue with further use of
one of the pool’s run or poll methods. While the function is running,
however, all tasks in the pool will try to make progress.
sourcepub fn try_run_one(&mut self) -> bool
pub fn try_run_one(&mut self) -> bool
Runs all tasks and returns after completing one future or until no more progress
can be made. Returns true
if one future was completed, false
otherwise.
use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};
let mut pool = LocalPool::new();
let spawner = pool.spawner();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();
// Run the two ready tasks and return true for them.
pool.try_run_one(); // returns true after completing one of the ready futures
pool.try_run_one(); // returns true after completing the other ready future
// the remaining task can not be completed
assert!(!pool.try_run_one()); // returns false
This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made or after exactly one task was completed; Remaining incomplete tasks in the pool can continue with further use of one of the pool’s run or poll methods. Though only one task will be completed, progress may be made on multiple tasks.
sourcepub fn run_until_stalled(&mut self)
pub fn run_until_stalled(&mut self)
Runs all tasks in the pool and returns if no more progress can be made on any task.
use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};
let mut pool = LocalPool::new();
let spawner = pool.spawner();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();
// Runs the two ready task and returns.
// The empty task remains in the pool.
pool.run_until_stalled();
This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made; remaining incomplete tasks in the pool can continue with further use of one of the pool’s run or poll methods. While the function is running, all tasks in the pool will try to make progress.