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

pub fn new() -> LocalPool

Create a new, empty pool of tasks.

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,

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,

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

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for LocalPool

fn default() -> Self

Returns the "default value" for a type.