[−][src]Struct futures_executor::LocalPool
pub struct LocalPool { /* fields omitted */ }
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
.
Methods
impl LocalPool
[src]
impl LocalPool
pub fn new() -> LocalPool
[src]
pub fn new() -> LocalPool
Create a new, empty pool of tasks.
pub fn spawner(&self) -> LocalSpawn
[src]
pub fn spawner(&self) -> LocalSpawn
Get a clonable handle to the pool as a Spawn
.
pub fn run<Sp>(&mut self, spawn: &mut Sp) where
Sp: Spawn + Sized,
[src]
pub fn run<Sp>(&mut self, spawn: &mut Sp) where
Sp: Spawn + Sized,
Run all tasks in the pool to completion.
The given spawner, spawn
, is used as the default spawner for any
newly-spawned tasks. You can route these additional tasks back into
the LocalPool
by using its spawner handle:
use futures::executor::LocalPool; let mut pool = LocalPool::new(); let mut spawn = pool.spawner(); // ... 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(&mut spawn);
The function will block the calling thread until all tasks in the pool are complete, including any spawned while running existing tasks.
pub fn run_until<F, Sp>(&mut self, future: F, spawn: &mut Sp) -> F::Output where
F: Future,
Sp: Spawn + Sized,
[src]
pub fn run_until<F, Sp>(&mut self, future: F, spawn: &mut Sp) -> F::Output where
F: Future,
Sp: Spawn + Sized,
Runs all the tasks in the pool until the given future completes.
The given spawner, spawn
, is used as the default spawner for any
newly-spawned tasks. You can route these additional tasks back into
the LocalPool
by using its spawner handle:
#![feature(pin, arbitrary_self_types, futures_api)] use futures::executor::LocalPool; use futures::future::ready; let mut pool = LocalPool::new(); let mut spawn = pool.spawner(); // run tasks in the pool until `my_app` completes, by default spawning // further tasks back onto the pool pool.run_until(my_app, &mut spawn);
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
run
or run_until
. While the function is running, however, all tasks
in the pool will try to make progress.
Trait Implementations
impl Debug for LocalPool
[src]
impl Debug for LocalPool
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl Default for LocalPool
[src]
impl Default for LocalPool