Struct procspawn::Pool

pub struct Pool { /* private fields */ }

A process pool.

This works similar to spawn but lets you retain a pool of processes. Since procspawn is intended to isolate potentially crashing code the pool will automatically restart broken processes.

Note that it’s not possible to intercept streams of processes spawned through the pool.

When the process pool is dropped all processes are killed.

This requires the pool feature.

Implementations

impl Pool

pub fn new(size: usize) -> Result<Pool, SpawnError>

Creates the default pool.

Examples found in repository

examples/pool.rs (line 8)

fn main() {
    procspawn::init();

    let pool = Pool::new(4).unwrap();
    let mut handles = vec![];

    for counter in 0..8 {
        handles.push(procspawn::spawn!(in pool, (counter) || {
            thread::sleep(Duration::from_millis(500));
            counter
        }));
    }

    for handle in handles {
        match handle.join() {
            Ok(val) => println!("got result: {}", val),
            Err(err) => {
                let panic = err.panic_info().expect("got a non panic error");
                println!("process panicked with {}", panic.message());
                println!("{:#?}", panic);
            }
        }
    }

    pool.shutdown();
}

pub fn builder(size: usize) -> PoolBuilder

Creates a builder to customize pool creation.

pub fn size(&self) -> usize

Returns the size of the pool.

pub fn queued_count(&self) -> usize

Returns the number of jobs waiting to executed in the pool.

pub fn active_count(&self) -> usize

Returns the number of currently active threads.

pub fn spawn<A: Serialize + DeserializeOwned, R: Serialize + DeserializeOwned + Send + 'static>( &self, args: A, func: fn(_: A) -> R ) -> JoinHandle<R>

Spawns a closure into a process of the pool.

This works exactly like procspawn::spawn but instead of spawning a new process, it reuses a process from the pool.

pub fn join(&self)

Joins the process pool.

pub fn shutdown(&self)

Joins and shuts down.

Examples found in repository

examples/pool.rs (line 29)

fn main() {
    procspawn::init();

    let pool = Pool::new(4).unwrap();
    let mut handles = vec![];

    for counter in 0..8 {
        handles.push(procspawn::spawn!(in pool, (counter) || {
            thread::sleep(Duration::from_millis(500));
            counter
        }));
    }

    for handle in handles {
        match handle.join() {
            Ok(val) => println!("got result: {}", val),
            Err(err) => {
                let panic = err.panic_info().expect("got a non panic error");
                println!("process panicked with {}", panic.message());
                println!("{:#?}", panic);
            }
        }
    }

    pool.shutdown();
}

pub fn kill(&self)

Hard kills all processes in the pool.

After calling this the pool cannot be used any more.

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)

Executes the destructor for this type.