Struct tokio::executor::thread_pool::Sender

pub struct Sender { /* fields omitted */ }

Submit futures to the associated thread pool for execution.

A Sender instance is a handle to a single thread pool, allowing the owner of the handle to spawn futures onto the thread pool. New futures are spawned using Sender::spawn.

The Sender handle is only used for spawning new futures. It does not impact the lifecycle of the thread pool in any way.

Sender instances are obtained by calling ThreadPool::sender. The Sender struct implements the Executor trait.

Methods

impl Sender

pub fn spawn<F>(&self, future: F) -> Result<(), SpawnError> where
    F: Future<Item = (), Error = ()> + Send + 'static, 

Spawn a future onto the thread pool

This function takes ownership of the future and spawns it onto the thread pool, assigning it to a worker thread. The exact strategy used to assign a future to a worker depends on if the caller is already on a worker thread or external to the thread pool.

If the caller is currently on the thread pool, the spawned future will be assigned to the same worker that the caller is on. If the caller is external to the thread pool, the future will be assigned to a random worker.

If spawn returns Ok, this does not mean that the future will be executed. The thread pool can be forcibly shutdown between the time spawn is called and the future has a chance to execute.

If spawn returns Err, then the future failed to be spawned. There are two possible causes:

• The thread pool is at capacity and is unable to spawn a new future. This is a temporary failure. At some point in the future, the thread pool might be able to spawn new futures.
• The thread pool is shutdown. This is a permanent failure indicating that the handle will never be able to spawn new futures.

The status of the thread pool can be queried before calling spawn using the status function (part of the Executor trait).

Examples

use futures::future::{Future, lazy};

// Create a thread pool with default configuration values
let thread_pool = ThreadPool::new();

thread_pool.sender().spawn(lazy(|| {
    println!("called from a worker thread");
    Ok(())
})).unwrap();

// Gracefully shutdown the threadpool
thread_pool.shutdown().wait().unwrap();

Trait Implementations

impl Debug for Sender

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

Formats the value using the given formatter.

impl Clone for Sender

fn clone(&self) -> Sender

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Executor<T> for Sender where
    T: Future<Item = (), Error = ()> + Send + 'static, 

fn execute(&self, future: T) -> Result<(), ExecuteError<T>>

Spawns a future to run on this Executor, typically in the "background".

impl<'a> Executor for &'a Sender

fn status(&self) -> Result<(), SpawnError>

Provides a best effort hint to whether or not spawn will succeed.

fn spawn(
    &mut self,
    future: Box<Future<Item = (), Error = ()> + 'static + Send>
) -> Result<(), SpawnError>

Spawns a future object to run on this executor.

impl Executor for Sender

fn status(&self) -> Result<(), SpawnError>

Provides a best effort hint to whether or not spawn will succeed.

fn spawn(
    &mut self,
    future: Box<Future<Item = (), Error = ()> + 'static + Send>
) -> Result<(), SpawnError>

Spawns a future object to run on this executor.