[][src]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[src]

pub fn new() -> LocalPool[src]

Create a new, empty pool of tasks.

pub fn spawner(&self) -> LocalSpawner[src]

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

pub fn run(&mut self)[src]

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

// ... 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
[src]

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:

use futures::executor::LocalPool;
use futures::future::ready;

let mut pool = LocalPool::new();

// run tasks in the pool until `my_app` completes, by default spawning
// further tasks back onto the pool
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[src]

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)[src]

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[src]

impl Debug for LocalPool[src]

Auto Trait Implementations

impl !Sync for LocalPool

impl !Send for LocalPool

impl Unpin for LocalPool

impl !UnwindSafe for LocalPool

impl !RefUnwindSafe for LocalPool

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,