Struct ThreadPool 

pub struct ThreadPool { /* private fields */ }

A handle to a crossbeam_channel_pool

See module level documentation for usage information.

Implementations

impl ThreadPool

pub fn new(threads: usize) -> ThreadPool

Creates a new thread pool capable of executing threads number of jobs concurrently.

Panics

This function will panic if threads is 0.

Core Affinity

If compiled with thread-pinning it will assign a worker to each cores, until it runs out of cores or workers. If there are more workers than cores, the extra workers will be “floating”, i.e. not pinned.

Examples

Create a new thread pool capable of executing four jobs concurrently:

use executors::*;
use executors::crossbeam_channel_pool::ThreadPool;

let pool = ThreadPool::new(4);

pub fn with_affinity(cores: &[CoreId], floating: usize) -> ThreadPool

Creates a new thread pool capable of executing threads number of jobs concurrently with a particular core affinity.

For each core id in the core slice, it will generate a single thread pinned to that id. Additionally, it will create floating number of unpinned threads.

Panics

This function will panic if cores.len() + floating is 0.

Trait Implementations

impl CanExecute for ThreadPool

fn execute_job(&self, job: Box<dyn FnOnce() + Send + 'static>)

Executes the function job on the Executor.

impl Clone for ThreadPool

fn clone(&self) -> ThreadPool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ThreadPool

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

Formats the value using the given formatter.

impl Default for ThreadPool

Create a thread pool with one thread per CPU. On machines with hyperthreading, this will create one thread per hyperthread.

fn default() -> Self

Returns the “default value” for a type.

impl Executor for ThreadPool

fn shutdown_async(&self)

Shutdown the Executor without waiting.

fn shutdown_borrowed(&self) -> Result<(), String>

Same as shutdown but without consuming self

fn execute<F>(&self, job: F)

where F: FnOnce() + Send + 'static,

Executes the function job on the Executor.

fn shutdown(self) -> Result<(), String>

Shutdown an Executor and wait for it to shut down all workers.

impl FuturesExecutor for ThreadPool

fn spawn<R: Send + 'static>( &self, future: impl Future<Output = R> + 'static + Send, ) -> JoinHandle<R>

Spawn future on the pool and return a handle to the result