Struct ThreadPool 

pub struct ThreadPool { /* private fields */ }

Implementations

impl ThreadPool

pub fn new(pool_size: u8) -> Self

Creates a new thread pool with the following behavior constraints:

• pool_size is 0: runs in multithreaded default mode using maximum parallelism
• pool_size is 1: runs in single-threaded mode (all jobs are run in the main thread)
• pool_size is 1<N<=255: runs in multithreaded mode with N jobs

pub fn execute<F>(&self, f: F) -> Result<(), Box<dyn Error>>

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

Executes a job on the thread pool.

Behavior

• Single-threaded mode (max_jobs=1): Job executes synchronously in the calling thread
• Multi-threaded mode: Job is queued and executed asynchronously by worker threads

pub fn is_single_threaded(&self) -> bool

Returns true if running in single-threaded mode.

Single-threaded mode is active when max_jobs=1, resulting in:

• No worker threads spawned
• No message passing channel created
• All jobs executed synchronously in the main thread

pub fn signal_stop(&self)

Signals all worker threads to stop processing after completing their current jobs.

This method sets the kill signal which workers check periodically. Workers will complete their current job before stopping. The pool’s Drop implementation will wait for all workers to finish.

pub fn get_kill_signal(&self) -> Arc<AtomicBool>

Returns a clone of the kill signal Arc that can be passed into jobs.

This allows jobs to signal the thread pool to stop from within the job itself. Useful for scenarios like finding a hash collision where one worker needs to stop all other workers.

Example

use jlizard_simple_threadpool::threadpool::ThreadPool;
use std::sync::atomic::Ordering;

let pool = ThreadPool::new(4);
let kill_signal = pool.get_kill_signal();

pool.execute(move || {
    // Do some work...
    if /* condition met */ true {
        // Signal all workers to stop
        kill_signal.store(true, Ordering::Relaxed);
    }
}).expect("Failed to execute");

Trait Implementations

impl Default for ThreadPool

fn default() -> Self

Returns the “default value” for a type.

impl Display for ThreadPool

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

Formats the value using the given formatter.

impl Drop for ThreadPool

fn drop(&mut self)

Executes the destructor for this type.