Struct futures::executor::LocalPool

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

pub fn new() -> LocalPool

Create a new, empty pool of tasks.

pub fn executor(&self) -> LocalExecutor

Get a clonable handle to the pool as an executor.

pub fn run(&mut self, exec: &mut Executor)

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 as Future>::Item, <F as Future>::Error> where     F: Future,

Runs all the tasks in the pool 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.