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,

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 as Future>::Output where     F: Future,     Sp: Spawn,

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<(), Error>

Formats the value using the given formatter.

impl Default for LocalPool

fn default() -> LocalPool

Returns the "default value" for a type.