Struct workerpool::Builder

pub struct Builder { /* private fields */ }

Pool factory, which can be used in order to configure the properties of the Pool.

The three configuration options available:

• num_threads: maximum number of threads that will be alive at any given moment by the built Pool
• thread_name: thread name for each of the threads spawned by the built Pool
• thread_stack_size: stack size (in bytes) for each of the threads spawned by the built Pool

Examples

Build a Pool that uses a maximum of eight threads simultaneously and each thread has a 8 MB stack size:

let pool = workerpool::Builder::new()
    .num_threads(8)
    .thread_stack_size(8_000_000)
    .build::<MyWorker>();

Implementations

impl Builder

pub fn new() -> Builder

Initiate a new Builder.

Examples

let builder = workerpool::Builder::new();

pub fn num_threads(self, num_threads: usize) -> Builder

Set the maximum number of worker-threads that will be alive at any given moment by the built Pool. If not specified, defaults the number of threads to the number of CPUs.

Panics

This method will panic if num_threads is 0.

Examples

No more than eight threads will be alive simultaneously for this pool:

use std::thread;
use workerpool::{Builder, Pool};
use workerpool::thunk::{Thunk, ThunkWorker};

let pool: Pool<ThunkWorker<()>> = Builder::new()
    .num_threads(8)
    .build();

for _ in 0..100 {
    pool.execute(Thunk::of(|| {
        println!("Hello from a worker thread!")
    }))
}

pub fn thread_name(self, name: String) -> Builder

Set the thread name for each of the threads spawned by the built Pool. If not specified, threads spawned by the thread pool will be unnamed.

Examples

Each thread spawned by this pool will have the name “foo”:

use std::thread;
use workerpool::{Builder, Pool};
use workerpool::thunk::{Thunk, ThunkWorker};

let pool: Pool<ThunkWorker<()>> = Builder::new()
    .thread_name("foo".into())
    .build();

for _ in 0..100 {
    pool.execute(Thunk::of(|| {
        assert_eq!(thread::current().name(), Some("foo"));
    }))
}

pub fn thread_stack_size(self, size: usize) -> Builder

Set the stack size (in bytes) for each of the threads spawned by the built Pool. If not specified, threads spawned by the workerpool will have a stack size as specified in the std::thread documentation.

Examples

Each thread spawned by this pool will have a 4 MB stack:

let pool: Pool<ThunkWorker<()>> = Builder::new()
    .thread_stack_size(4_000_000)
    .build();

for _ in 0..100 {
    pool.execute(Thunk::of(|| {
        println!("This thread has a 4 MB stack size!");
    }))
}

pub fn build<T>(self) -> Pool<T>

where T: Worker,

Finalize the Builder and build the Pool.

Examples

use workerpool::{Builder, Pool};
let pool: Pool<MyWorker> = Builder::new()
    .num_threads(8)
    .thread_stack_size(4_000_000)
    .build();

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.