Struct WorkerStatefulPool 

pub struct WorkerStatefulPool { /* private fields */ }

Available on crate feature rayon only.

Owns one run’s thread-local state on a shared WorkerPool.

Share this value with jobs through an Arc. Dropping the last handle clears this run’s state on every pool thread, leaving other runs’ state untouched. Worker slots retain only a weak reference to this owner and do not keep it alive. Dereferences to the underlying pool for scheduling jobs; each job accessing state must retain an owner handle.

Access closures borrow the current thread’s worker and must not yield to Rayon or recursively access worker state. Use them only in jobs executing on this pool. Cleanup broadcasts to the pool and blocks until complete; the last handle must be dropped outside worker access closures.

Implementations

impl WorkerStatefulPool

pub fn new(pool: Arc<WorkerPool>) -> Arc<Self>

Creates a shared state owner without initializing the pool or its workers.

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

Initializes this run’s state on every pool thread.

Offers existing state to f only when its run and type match. Otherwise, drops the previous state before calling f with None.

pub fn get<T: 'static, R>(&self, f: impl FnOnce(&T) -> R) -> R

Reads this run’s state on the current worker thread.

Panics

Panics if the worker is uninitialized, its run or type differs, or it is mutably borrowed.

pub fn get_or_init<T: 'static, R>( &self, init: impl FnOnce() -> T, f: impl FnOnce(&mut T) -> R, ) -> R

Mutably accesses this run’s state, initializing it on the current worker if needed.

Reuses state without calling init when both its run and type match. Otherwise, drops the previous state before calling init. If init panics, the worker remains uninitialized.

Panics

Panics if the current worker is already borrowed.

Methods from Deref<Target = WorkerPool>

pub fn is_initialized(&self) -> bool

Returns true if the underlying rayon pool has been initialized.

pub fn num_threads(&self) -> usize

Returns the number of threads the pool is configured with, without creating it.

pub fn current_num_threads(&self) -> usize

Returns the total number of threads in the underlying rayon 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.

The closure runs with exclusive access to each selected thread’s worker. Only num_threads threads execute the closure; the rest skip it.

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.

Trait Implementations

impl Debug for WorkerStatefulPool

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

Formats the value using the given formatter.

impl Deref for WorkerStatefulPool

type Target = WorkerPool

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Drop for WorkerStatefulPool

fn drop(&mut self)

Executes the destructor for this type.

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

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

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

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