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) -> LocalSpawner

Get a clonable handle to the pool as a [Spawn].

pub fn run(&mut self)

Run all tasks in the pool to completion.

use futures::executor::LocalPool;

let mut pool = LocalPool::new();

// ... 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();

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, future: F) -> <F as Future>::Output where
    F: Future, 

Runs all the tasks in the pool until the given future completes.

use futures::executor::LocalPool;

let mut pool = LocalPool::new();

// run tasks in the pool until `my_app` completes
pool.run_until(my_app);

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 one of the pool's run or poll methods. While the function is running, however, all tasks in the pool will try to make progress.

pub fn try_run_one(&mut self) -> bool

Runs all tasks and returns after completing one future or until no more progress can be made. Returns true if one future was completed, false otherwise.

use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};

let mut pool = LocalPool::new();
let mut spawner = pool.spawner();

spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();

// Run the two ready tasks and return true for them.
pool.try_run_one(); // returns true after completing one of the ready futures
pool.try_run_one(); // returns true after completing the other ready future

// the remaining task can not be completed
assert!(!pool.try_run_one()); // returns false

This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made or after exactly one task was completed; Remaining incomplete tasks in the pool can continue with further use of one of the pool's run or poll methods. Though only one task will be completed, progress may be made on multiple tasks.

pub fn run_until_stalled(&mut self)

Runs all tasks in the pool and returns if no more progress can be made on any task.

use futures::executor::LocalPool;
use futures::task::LocalSpawnExt;
use futures::future::{ready, pending};

let mut pool = LocalPool::new();
let mut spawner = pool.spawner();

spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(ready(())).unwrap();
spawner.spawn_local(pending()).unwrap();

// Runs the two ready task and returns.
// The empty task remains in the pool.
pool.run_until_stalled();

This function will not block the calling thread and will return the moment that there are no tasks left for which progress can be made; remaining incomplete tasks in the pool can continue with further use of one of the pool's run or poll methods. While the function is running, all tasks in the pool will try to make progress.

Trait Implementations

impl Default for LocalPool

fn default() -> LocalPool

Returns the "default value" for a type.

impl Debug for LocalPool

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

Formats the value using the given formatter.