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.

Worker access is backed by a thread-local RefCell. Keep with_worker and with_worker_mut closures short and non-yielding: if Rayon runs another job on the same thread while a borrow is active, re-entrant worker access can panic.

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_and_wait<R: Send + 'static>( &self, f: impl FnOnce() -> R + Send + 'static, ) -> R

Runs a closure on this pool, waiting for its result.

Unlike install_fn, this always queues the closure onto this pool when called from another rayon pool. This avoids Rayon running the closure on the caller’s worker through its cross-pool install path.

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

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

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

This borrows the thread-local worker for the entire duration of f. Do not yield to Rayon from inside f if another job could call with_worker_mut on the same thread. Yield points include parallel iterators, rayon::join, scopes, and waiting in ThreadPool::install on a different Rayon pool. A cross-pool install may run another job from the caller’s pool on the same thread while it waits.

Prefer copying or cloning the required worker state in f, returning from this method to release the borrow, and only then performing work that may yield.

Panics

Panics if the current thread’s worker is already mutably borrowed, including by a re-entrant with_worker_mut call.

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

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

This exclusively borrows the thread-local worker for the entire duration of f. The borrow is not re-entrant: if Rayon runs another job on the same thread before f returns, any call to with_worker or with_worker_mut from that job will panic.

Do not call operations that can yield to Rayon from inside f when re-entrant worker access is possible. This includes parallel iterators, rayon::join, scopes, and waiting in ThreadPool::install on a different Rayon pool. In particular, a cross-pool install cooperatively runs jobs from the caller’s pool while waiting for the target pool.

Prefer computing updates before entering with_worker_mut, then use this closure only to apply the update to the worker state.

Panics

Panics if the current thread’s worker is already borrowed, including by a re-entrant with_worker or with_worker_mut call.

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: 80 bytes