Struct futures_executor::LocalPool
[−]
[src]
pub struct LocalPool { /* fields omitted */ }
A single-threaded task pool.
This executor allows you to multiplex any number of tasks onto a single thread. It's appropriate for strictly I/O-bound tasks that do very little work in between I/O actions.
To get a handle to the pool that implements
Executor
, use the
executor()
method. Because the executor is
single-threaded, it supports a special form of task spawning for non-Send
futures, via spawn_local
.
Methods
impl LocalPool
[src]
pub fn new() -> LocalPool
[src]
Create a new, empty pool of tasks.
pub fn executor(&self) -> LocalExecutor
[src]
Get a clonable handle to the pool as an executor.
pub fn run(&mut self, exec: &mut Executor)
[src]
Run all tasks in the pool to completion.
The given executor, exec
, is used as the default executor for any
newly-spawned tasks. You can route these additional tasks back into
the LocalPool
by using its executor handle:
let mut pool = LocalPool::new(); let mut exec = pool.executor(); // ... spawn some initial tasks using `exec.spawn()` or `exec.spawn_local()` // run *all* tasks in the pool to completion, including any newly-spawned ones. pool.run(&mut exec);
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>(
&mut self,
f: F,
exec: &mut Executor
) -> Result<F::Item, F::Error> where
F: Future,
[src]
&mut self,
f: F,
exec: &mut Executor
) -> Result<F::Item, F::Error> where
F: Future,
Runs all the tasks in the pull until the given future completes.
The given executor, exec
, is used as the default executor for any
newly-spawned tasks. You can route these additional tasks back into
the LocalPool
by using its executor handle:
let mut pool = LocalPool::new(); let mut exec = pool.executor(); // run tasks in the pool until `my_app` completes, by default spawning // further tasks back onto the pool pool.run_until(my_app, &mut exec);
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.