[][src]Struct tokio_threadpool::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[src]

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

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 Clone for Sender[src]

impl Debug for Sender[src]

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

impl Executor for Sender[src]

impl<'a> Executor for &'a Sender[src]

impl<T> TypedExecutor<T> for Sender where
    T: Future<Item = (), Error = ()> + Send + 'static, 
[src]

Auto Trait Implementations

impl Send for Sender

impl Sync for Sender

impl Unpin for Sender

impl !UnwindSafe for Sender

impl !RefUnwindSafe for Sender

Blanket Implementations

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

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

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

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

type Error = !

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> Borrow<T> for T where
    T: ?Sized
[src]

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

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