Struct Pool 

pub struct Pool { /* private fields */ }

A pool of worker threads that execute submitted tasks concurrently.

The Pool manages a set of worker threads, each with its own local work queue. Tasks are distributed between threads using a global Injector and work stealing between local queues.

When dropped, the pool gracefully shuts down by preventing new submissions and joining all worker threads.

Examples

use foofighters::pool::PoolBuilder;

let pool = PoolBuilder::new()
    .set_worker_count(4)
    .build();

pool.spawn(|| println!("Task executed!"));
// The pool is automatically joined when dropped.

Implementations

impl Pool

pub fn spawn<T>(&self, task: T) -> TaskSubmission

where T: FnOnce() + Send + 'static,

Submits a new task to the pool for concurrent execution.

The task must implement FnOnce() + Send + 'static. If the pool has been shut down, the task will be rejected with TaskSubmission::Blocked.

Examples

use foofighters::pool::{PoolBuilder, TaskSubmission};

let pool = PoolBuilder::new().build();
let result = pool.spawn(|| println!("Running a task"));
assert!(result.into_result().is_ok());

Trait Implementations

impl Debug for Pool

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

Formats the value using the given formatter.

impl Drop for Pool

fn drop(&mut self)

Gracefully shuts down the pool by joining all worker threads.

This method is automatically invoked when the pool goes out of scope. It prevents further submissions and waits for all active worker threads to complete their tasks.

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.