Struct tokio_threadpool::ThreadPool[][src]

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

Create a new ThreadPool with default values.

Use Builder for creating a configured thread pool.

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.

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.

Return a reference to the sender handle

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

Return a mutable reference to the sender handle

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.

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.

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 Debug for ThreadPool
[src]

Formats the value using the given formatter. Read more

impl Drop for ThreadPool
[src]

Executes the destructor for this type. Read more

Auto Trait Implementations

impl Send for ThreadPool

impl Sync for ThreadPool