Struct ThreadPoolBuilder 

pub struct ThreadPoolBuilder { /* private fields */ }

A builder of the ThreadPool, which can be used to configure the properties of a new thread pool.

Examples

use jtp::ThreadPoolBuilder;
use jtp::RejectedTaskHandler;
use std::time::Duration;

let thread_pool = ThreadPoolBuilder::default()
    .core_pool_size(4)
    .max_pool_size(7)
    .keep_alive_time(Duration::from_secs(2))
    .rejected_handler(RejectedTaskHandler::Discard)
    .lisenter_before_execute(|id| println!("the task {} will be executed.", id))
    .lisenter_before_execute(|id| println!("the task {} has been executed.", id))
    .thread_factory_fn(|| {
        std::thread::Builder::new().stack_size(1024 * 4)
    })
    .build();

Implementations

impl ThreadPoolBuilder

pub fn new() -> Self

Creates the base configuration for the new thread pool.

See: ThreadPoolBuilder::default

pub fn channel_capacity(self, capacity: usize) -> Self

Sets the capacity of the bounded task channel.

pub fn max_pool_size(self, size: usize) -> Self

Sets the maximum allowed number of threads.

pub fn core_pool_size(self, size: usize) -> Self

Sets the number of core threads.

pub fn keep_alive_time(self, time: Duration) -> Self

Sets the time that non-core threads may remain idle.

pub fn rejected_handler(self, handler: RejectedTaskHandler) -> Self

Sets the policy to handle rejected tasks.

When you execute a task, it will be handled by the given handler if the thread pool and the task channel are both full.

pub fn lisenter_before_execute<F>(self, executor: F) -> Self

where F: Fn(usize) + Send + Sync + 'static,

Sets the listener function that will be invoked before a task is executed.

pub fn lisenter_after_execute<F>(self, executor: F) -> Self

where F: Fn(usize) + Send + Sync + 'static,

Sets the listener function that will be invoked after a task is executed.

pub fn thread_factory_fn<F>(self, f: F) -> Self

where F: Fn() -> Builder + Send + Sync + 'static,

Sets the factory function that is used to create a new custom thread.

pub fn build(self) -> ThreadPool

Creates a thread pool with the arguments.

Panics

Panics if the builder with invalid arguments.

Trait Implementations

impl Default for ThreadPoolBuilder

fn default() -> Self

Creates a new builder with the default configuration.

Default Configuration

• channel_capacity: 1000
• max_pool_size: the number of physical cores of the current system
• core_pool_size: the half of the max_pool_size at least 1
• keep_alive_time: 1 second
• rejected_task_handler: RejectedTaskHandler::Abort
• before_execute: an empty closure |_| ()
• after_execute: an empty closure |_| ()
• thread_factory: || thread::Builder::new()