Struct tokio_threadpool::ThreadPool

pub struct ThreadPool { /* fields omitted */ }

Work-stealing based thread pool for executing futures.

If a ThreadPool instance is dropped without explicitly being shutdown, shutdown_now is called implicitly, forcing all tasks that have not yet completed to be dropped.

Create ThreadPool instances using Builder.

Methods

impl ThreadPool

pub fn new() -> ThreadPool

Create a new ThreadPool with default values.

Use Builder for creating a configured thread pool.

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

Spawn a future onto the thread pool.

This function takes ownership of the future and randomly assigns it to a worker thread. The thread will then start executing the future.

Examples

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

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

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

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

Panics

This function panics if the spawn fails. Use [Sender::spawn] for a version that returns a Result instead of panicking.

pub fn spawn_handle<F>(&self, future: F) -> SpawnHandle<F::Item, F::Error> where
    F: Future + Send + 'static,
    F::Item: Send + 'static,
    F::Error: Send + 'static, 

Spawn a future on to the thread pool, return a future representing the produced value.

The SpawnHandle returned is a future that is a proxy for future itself. When future completes on this thread pool then the SpawnHandle will itself be resolved.

Examples

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

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

let handle = thread_pool.spawn_handle(lazy(|| Ok::<_, ()>(42)));

let value = handle.wait().unwrap();
assert_eq!(value, 42);

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

Panics

This function panics if the spawn fails.

pub fn sender(&self) -> &Sender

Return a reference to the sender handle

The handle is used to spawn futures onto the thread pool. It also implements the Executor trait.

pub fn sender_mut(&mut self) -> &mut Sender

Return a mutable reference to the sender handle

pub fn shutdown_on_idle(self) -> Shutdown

Shutdown the pool once it becomes idle.

Idle is defined as the completion of all futures that have been spawned onto the thread pool. There may still be outstanding handles when the thread pool reaches an idle state.

Once the idle state is reached, calling spawn on any outstanding handle will result in an error. All worker threads are signaled and will shutdown. The returned future completes once all worker threads have completed the shutdown process.

pub fn shutdown(self) -> Shutdown

Shutdown the pool

This prevents the thread pool from accepting new tasks but will allow any existing tasks to complete.

Calling spawn on any outstanding handle will result in an error. All worker threads are signaled and will shutdown. The returned future completes once all worker threads have completed the shutdown process.

pub fn shutdown_now(self) -> Shutdown

Shutdown the pool immediately

This will prevent the thread pool from accepting new tasks and abort any tasks that are currently running on the thread pool.

Calling spawn on any outstanding handle will result in an error. All worker threads are signaled and will shutdown. The returned future completes once all worker threads have completed the shutdown process.

Trait Implementations

impl Drop for ThreadPool

fn drop(&mut self)

Executes the destructor for this type.

impl Debug for ThreadPool

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

Formats the value using the given formatter.