Struct ThreadPool

Source

pub struct ThreadPool { /* private fields */ }

Implementations§

Source §

impl ThreadPool

Source

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

Source

pub fn max_jobs(self, limit: usize) -> Self

Sets the maximum number of jobs that can be queued at once.

When the queue is full, execute() will block with exponential backoff (1ms → 50ms ceiling) until a slot becomes available.

§Arguments

limit - Maximum number of jobs (must be > 0)

§Panics

Panics if limit is 0.

§Example

use jlizard_simple_threadpool::threadpool::ThreadPool;

let pool = ThreadPool::new(4).max_jobs(100_000);

Source

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

§Backpressure

When the job queue reaches max_jobs capacity, this method blocks with exponential backoff (starting at 1ms, doubling up to 50ms ceiling) until a slot becomes available.

§Errors

Returns an error if the worker threads have been dropped or the channel is closed.

Source

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

Source

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.

Source

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");