Struct ThreadPool 

pub struct ThreadPool { /* private fields */ }

Thread pool that allows to change number of threads at runtime.

On Drop it instructs threads to shutdown, but doesn’t await for them to finish

Note

The pool doesn’t implement any sort of flow control. If workers are busy, message will remain in queue until any other thread can take it.

Clone

Thread pool intentionally doesn’t implement Clone If you want to share it, then share it by using global variable or on heap. It is thread safe, so concurrent access is allowed.

Panic

Each thread wraps execution of job into catch_unwind to ensure that thread is not aborted on panic

Implementations

impl ThreadPool

pub const fn new() -> Self

Creates new thread pool with default params

pub const fn with_defaults(name: &'static str, stack_size: usize) -> Self

Creates new instance by specifying all params

pub fn set_stack_size(&self, stack_size: usize) -> usize

Sets stack size to use.

By default it uses default value, used by Rust’s stdlib. But setting this variable overrides it, allowing to customize it.

This setting takes effect only when creating new threads

pub fn set_threads(&self, thread_num: u16) -> Result<u16>

Sets worker number, starting new threads if it is greater than previous

In case if it is less, extra threads are shut down. Returns previous number of threads.

By default when pool is created no threads are started.

If any thread fails to start, function returns immediately with error.

Note

Any calls to this method are serialized, which means under hood it locks out any attempt to change number of threads, until it is done

pub fn shutdown(&mut self)

Terminates all threads and clears internal state

Mutable access guarantees that only one writer can clear state without need of internal lock

pub fn shutdown_and_join(&mut self)

Terminates all threads, awaiting their completion and clears internal state

Mutable access guarantees that only one writer can clear state without need of internal lock

pub fn spawn<F: FnOnce() + Send + 'static>(&self, job: F)

Schedules new execution, sending it over to one of the workers.

pub fn spawn_handle<R: Send + 'static, F: FnOnce() -> R + Send + 'static>( &self, job: F, ) -> JobHandle<R>

Schedules execution, that allows to await and receive it’s result.

Trait Implementations

impl Debug for ThreadPool

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for ThreadPool

fn drop(&mut self)

Executes the destructor for this type.

impl Sync for ThreadPool