Struct FixedThreadPool 

pub struct FixedThreadPool { /* private fields */ }

Fixed-size thread pool implementing ExecutorService.

FixedThreadPool prestarts a fixed number of worker threads and does not support runtime pool-size changes. Use crate::ThreadPool when dynamic core/maximum sizes or keep-alive policies are required.

Implementations

impl FixedThreadPool

pub fn new(pool_size: usize) -> Result<Self, ExecutorServiceBuilderError>

Creates a fixed thread pool with pool_size prestarted workers.

Parameters

• pool_size - Number of worker threads.

Returns

A fixed thread pool.

Errors

Returns ExecutorServiceBuilderError if the worker count is zero or a worker cannot be spawned.

pub fn builder() -> FixedThreadPoolBuilder

Creates a fixed pool builder.

Returns

Builder with CPU parallelism defaults.

pub fn pool_size(&self) -> usize

Returns the fixed worker count.

Returns

Number of workers in this pool.

pub fn queued_count(&self) -> usize

Returns the queued task count.

Returns

Number of accepted tasks waiting to run.

pub fn running_count(&self) -> usize

Returns the running task count.

Returns

Number of tasks currently held by workers.

pub fn live_worker_count(&self) -> usize

Returns the live worker count.

Returns

Number of worker loops that have not exited.

pub fn stats(&self) -> ThreadPoolStats

Returns a point-in-time stats snapshot.

Returns

Snapshot containing queue, worker, and lifecycle counters.

pub fn join(&self)

Blocks until all accepted work has completed.

This is a join-style wait for quiescence: it does not request shutdown and does not wait for worker threads to exit. Concurrent submissions may extend the wait until those accepted jobs also drain.

Trait Implementations

impl Default for FixedThreadPool

fn default() -> Self

Creates a fixed thread pool using FixedThreadPoolBuilder::default.

Returns

A fixed thread pool with CPU parallelism defaults and prestarted workers.

Panics

Panics when the default builder fails to spawn a worker thread.

impl Drop for FixedThreadPool

fn drop(&mut self)

Requests graceful shutdown when the pool handle is dropped.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl ExecutorService for FixedThreadPool

fn submit<T, E>(&self, task: T) -> Result<(), SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Accepts a runnable and queues it for fixed pool workers.

fn submit_callable<C, R, E>( &self, task: C, ) -> Result<Self::ResultHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Accepts a callable and queues it for fixed pool workers.

Parameters

• task - Callable to execute on a fixed pool worker.

Returns

A TaskHandle for the accepted task.

Errors

Returns SubmissionError::Shutdown after shutdown or SubmissionError::Saturated when a bounded queue is full.

fn submit_tracked_callable<C, R, E>( &self, task: C, ) -> Result<Self::TrackedHandle<R, E>, SubmissionError>

where C: Callable<R, E> + Send + 'static, R: Send + 'static, E: Send + 'static,

Accepts a callable and queues it with a tracked handle.

Parameters

• task - Callable to execute on a fixed pool worker.

Returns

A TrackedTask that reports task status and can observe completion, failure, or queued cancellation.

Errors

Returns SubmissionError::Shutdown after shutdown or SubmissionError::Saturated when a bounded queue is full.

fn shutdown(&self)

Stops accepting new work and drains accepted queued tasks.

fn stop(&self) -> StopReport

Stops accepting work and cancels queued tasks.

Returns

A count-based shutdown report.

fn lifecycle(&self) -> ExecutorServiceLifecycle

Returns the current lifecycle state.

fn is_not_running(&self) -> bool

Returns whether shutdown has been requested.

Returns

true when this pool no longer accepts new work.

fn is_terminated(&self) -> bool

Returns whether this pool is fully terminated.

Returns

true after shutdown and after all workers have exited.

fn wait_termination(&self)

Blocks until this fixed pool has terminated.

type ResultHandle<R, E> = TaskHandle<R, E> where R: Send + 'static, E: Send + 'static

Result handle returned for an accepted callable task.

type TrackedHandle<R, E> = TrackedTask<R, E> where R: Send + 'static, E: Send + 'static

Tracked handle returned for accepted tasks that expose status.

fn submit_tracked<T, E>( &self, task: T, ) -> Result<Self::TrackedHandle<(), E>, SubmissionError>

where T: Runnable<E> + Send + 'static, E: Send + 'static,

Submits a runnable task and returns a tracked handle.

fn is_running(&self) -> bool

Returns whether the service accepts new tasks.

fn is_shutting_down(&self) -> bool

Returns whether graceful shutdown is in progress.

fn is_stopping(&self) -> bool

Returns whether abrupt stop is in progress.