Struct WorkerPool 

pub struct WorkerPool { /* private fields */ }

Available on crate feature rayon only.

A rayon thread pool with per-thread Worker state.

Each thread in the pool has its own Worker that can hold arbitrary state via Worker::init. The state is thread-local and accessible during install calls.

The pool supports multiple init/clear cycles, allowing reuse of the same threads with different state configurations.

The underlying rayon pool is created lazily on first access.

Implementations

impl WorkerPool

pub const fn new(num_threads: usize, thread_name_prefix: &'static str) -> Self

Creates a new lazy WorkerPool with the given number of threads and a thread name prefix.

The underlying rayon pool is not created until the first method that requires it is called. Thread names follow the pattern "{prefix}-{index:02}".

pub fn is_initialized(&self) -> bool

Returns true if the underlying rayon pool has been initialized.

pub fn current_num_threads(&self) -> usize

Returns the total number of threads in the underlying rayon pool.

pub fn init<T: 'static>(&self, f: impl Fn(Option<&mut T>) -> T + Sync)

Initializes per-thread Worker state on every thread in the pool.

pub fn broadcast(&self, num_threads: usize, f: impl Fn(&mut Worker) + Sync)

Runs a closure on num_threads threads in the pool, giving mutable access to each thread’s Worker.

Use this to initialize or re-initialize per-thread state via Worker::init. Only num_threads threads execute the closure; the rest skip it.

pub fn clear(&self)

Clears the state on every thread in the pool.

pub fn install<R: Send>(&self, f: impl FnOnce(&Worker) -> R + Send) -> R

Runs a closure on the pool with access to the calling thread’s Worker.

All rayon parallelism (e.g. par_iter) spawned inside the closure executes on this pool. Each thread can access its own Worker via the provided reference or through additional WorkerPool::with_worker calls.

pub fn install_fn<R: Send>(&self, f: impl FnOnce() -> R + Send) -> R

Runs a closure on the pool without worker state access.

Like install but for closures that don’t need per-thread Worker state.

pub fn spawn(&self, f: impl FnOnce() + Send + 'static)

Spawns a closure on the pool.

pub fn in_place_scope<'scope, R>( &self, f: impl FnOnce(&Scope<'scope>) -> R, ) -> R

Executes f on this pool using [rayon::in_place_scope], which converts the calling thread into a worker for the duration — tasks spawned inside the scope run on the pool and the call blocks until all of them complete.

pub fn with_worker<R>(f: impl FnOnce(&Worker) -> R) -> R

Access the current thread’s Worker from within an install closure.

This is useful for accessing the worker from inside par_iter where the initial &Worker reference from install belongs to a different thread.

pub fn with_worker_mut<R>(f: impl FnOnce(&mut Worker) -> R) -> R

Mutably access the current thread’s Worker from within a pool closure.

Trait Implementations

impl Debug for WorkerPool

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

Formats the value using the given formatter.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 40 bytes