Struct Builder 

pub struct Builder { /* private fields */ }

Pool’s Settings

extern crate poolite;
use poolite::Builder;

/// `cargo run --example without`
fn main() {
    let pool = Builder::new()
    .min(2)
    .max(9)
    .daemon(None)  // Close daemon
    .timeout(None) // Close timeout
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..33 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

fn test(msg: i32) {
    println!("key: {}\tvalue: {}", msg, fib(msg));
}

fn fib(msg: i32) -> i32 {
    match msg {
        0...2 => 1,
        x => fib(x - 1) + fib(x - 2),
    }
}

Implementations

impl Builder

pub fn num_cpus() -> usize

pub fn new() -> Self

Examples found in repository

examples/builder.rs (line 6)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn name<S>(self, name: S) -> Self

where S: Debug + Into<String>,

Sets thread’s name where them in the Pool,default is None('<unnamed>').

Examples found in repository

examples/builder.rs (line 11)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn name_get(&self) -> Option<&String>

pub fn stack_size(self, size: usize) -> Self

Sets thread’s stack_size where them in the Pool,default depends on OS.

Examples found in repository

examples/builder.rs (line 12)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn stack_size_get(&self) -> Option<&usize>

pub fn min(self, min: usize) -> Self

Sets the minimum number of threads in the Pool，default is num_cpus()+1.

Examples found in repository

examples/builder.rs (line 7)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn min_get(&self) -> &usize

pub fn max(self, max: usize) -> Self

Sets the maximum number of threads in the Pool，default is (num_cpus()+1)*num_cpus().

Examples found in repository

examples/builder.rs (line 8)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn max_get(&self) -> &usize

pub fn timeout_ms(self, timeout: Option<u64>) -> Self

Sets thread’s idle time(ms) except minimum number of threads,default is 5000(ms).

pub fn timeout(self, timeout: Option<Duration>) -> Self

Examples found in repository

examples/builder.rs (line 10)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn timeout_get(&self) -> Option<&Duration>

pub fn daemon_ms(self, daemon: Option<u64>) -> Self

Sets whether to open the daemon for the Pool, the default is Some(5000)(thread’s default idle time(ms)).

You can use None to close.

pub fn daemon(self, daemon: Option<Duration>) -> Self

Examples found in repository

examples/builder.rs (line 9)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

pub fn daemon_get(&self) -> Option<&Duration>

pub fn load_limit(self, load_limit: usize) -> Self

Sets the value of load_limit for the Pool.

default is num_cpus() * num_cpus().

pub fn load_limit_get(&self) -> &usize

pub fn build(self) -> Result<Pool, PoolError>

Examples found in repository

examples/builder.rs (line 13)

fn main() {
    let pool = Builder::new()
    .min(1)
    .max(9)
    .daemon(None) // Close
    .timeout(None) //Close
    .name("Worker")
    .stack_size(1024*1024*2) //2Mib
    .build()
    .unwrap();

    for i in 0..38 {
        pool.push(move || test(i));
    }

    pool.join(); //wait for the pool
    println!("{:?}", pool);
}

Trait Implementations

impl Debug for Builder

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

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Self

Returns the “default value” for a type.