Struct ThreadPool 

pub struct ThreadPool { /* private fields */ }

Thread Pool

A thread pool coordinates a group of threads to run taks in parallel.

Example

use job_pool::ThreadPool;

let pool = ThreadPool::with_size(32).expect("Error creating pool");
pool.execute(|| println!("Hello world!"));

Implementations

impl ThreadPool

pub fn new(config: PoolConfig) -> Result<ThreadPool>

Creates a new ThreadPool

Errors

If the PoolConfig is not valid

Examples found in repository

examples/scopes.rs (line 10)

pub fn main() {
    let conf = PoolConfig::builder().max_jobs(16).build();
    let pool = ThreadPool::new(conf).unwrap();

    let nums = (0..1000).collect::<Vec<_>>();

    let n = Mutex::new(0);

    fn delay() {
        use core::hash::BuildHasher;
        let rand = RandomState::new().build_hasher().finish();
        let millis = rand % 500;
        std::thread::sleep(Duration::from_millis(1000 + millis));
    }

    pool.scope(|scope| {
        scope.subscope(|sc| {
            sc.execute(|| {
                delay();
                *n.lock().unwrap() += nums.iter().sum::<usize>();
                println!("Sum1");
            });
            sc.execute(|| {
                delay();
                *n.lock().unwrap() += nums.iter().filter(|n| *n % 2 == 0).sum::<usize>();
                println!("Sum even");
            });
        });

        scope.subscope(|sc| {
            sc.execute(|| {
                delay();
                *n.lock().unwrap() *= nums.iter().max().unwrap();
                println!("Mul max");
            });

            sc.execute(|| {
                delay();
                *n.lock().unwrap() *= nums[nums.len() / 2];
                println!("Mul mid");
            });
        });
    });

    let mut expected = 0;
    expected += nums.iter().sum::<usize>();
    expected += nums.iter().filter(|n| *n % 2 == 0).sum::<usize>();
    expected *= nums.iter().max().unwrap();
    expected *= nums[nums.len() / 2];

    let n = *n.lock().unwrap();
    assert_eq!(n, expected);
    println!("{n} == {expected}");
}

pub fn with_default_config() -> Self

Create a ThreadPool with the default configuration

pub fn with_size(size: u16) -> Result<Self>

Create a ThreadPool with a given size

Examples found in repository

examples/example.rs (line 6)

pub fn main() {
    const N: i16 = 1024;
    let pool = ThreadPool::with_size(32).expect("Expected Ok value");
    let count = Arc::new(Mutex::new(0));

    let inc = |i: i16| {
        for _ in 0..N {
            let count = Arc::clone(&count);
            pool.execute(move || {
                let mut n = count.lock().unwrap();
                *n += i;
            })
        }
    };

    let check = |i: i16| {
        let n = count.lock().unwrap();
        assert_eq!(*n,i);
    };

    inc(1);
    pool.join();
    check(N);

    inc(-1);
    pool.join();
    check(0);
}

pub fn pending_jobs(&self) -> usize

Returns the number of pending jobs

pub fn execute(&self, job: impl Job<'static>)

Executes the given job inside this pool.

Example

use job_pool::ThreadPool;

fn heavy_computation(n: u64) -> u64 {
    // ....
    n
}

let pool = ThreadPool::default();
pool.execute(|| {
    println!("JOB1: {}", heavy_computation(1));
});

pool.execute(|| {
    println!("JOB2: {}", heavy_computation(2));
});

Examples found in repository

examples/example.rs (lines 12-15)

pub fn main() {
    const N: i16 = 1024;
    let pool = ThreadPool::with_size(32).expect("Expected Ok value");
    let count = Arc::new(Mutex::new(0));

    let inc = |i: i16| {
        for _ in 0..N {
            let count = Arc::clone(&count);
            pool.execute(move || {
                let mut n = count.lock().unwrap();
                *n += i;
            })
        }
    };

    let check = |i: i16| {
        let n = count.lock().unwrap();
        assert_eq!(*n,i);
    };

    inc(1);
    pool.join();
    check(N);

    inc(-1);
    pool.join();
    check(0);
}

pub fn scope<'scope, 'pool, F, R>(&'pool self, f: F) -> R

where F: FnOnce(&Scope<'scope, 'pool>) -> R, 'pool: 'scope,

Creates a new Scope to spawn jobs.

All the jobs spawned via Scope::execute, will be joined when the scope drops.

Example

use job_pool::ThreadPool;

let pool = ThreadPool::default();

let msg = String::from("Helloo :)");
pool.scope(|scope| {
    scope.execute(|| {
        println!("I'm job1, borrowing {msg:?}");
    });
    scope.execute(|| {
        println!("I'm job2, borrowing {msg:?}");
    });
});

// At this point, all the jobs spawned inside the scope above
// are done. That's wy it is ok to borrow msg, because we make
// sure that the jobs don't outlive the scope's lifetime.

Examples found in repository

examples/scopes.rs (lines 23-50)

pub fn main() {
    let conf = PoolConfig::builder().max_jobs(16).build();
    let pool = ThreadPool::new(conf).unwrap();

    let nums = (0..1000).collect::<Vec<_>>();

    let n = Mutex::new(0);

    fn delay() {
        use core::hash::BuildHasher;
        let rand = RandomState::new().build_hasher().finish();
        let millis = rand % 500;
        std::thread::sleep(Duration::from_millis(1000 + millis));
    }

    pool.scope(|scope| {
        scope.subscope(|sc| {
            sc.execute(|| {
                delay();
                *n.lock().unwrap() += nums.iter().sum::<usize>();
                println!("Sum1");
            });
            sc.execute(|| {
                delay();
                *n.lock().unwrap() += nums.iter().filter(|n| *n % 2 == 0).sum::<usize>();
                println!("Sum even");
            });
        });

        scope.subscope(|sc| {
            sc.execute(|| {
                delay();
                *n.lock().unwrap() *= nums.iter().max().unwrap();
                println!("Mul max");
            });

            sc.execute(|| {
                delay();
                *n.lock().unwrap() *= nums[nums.len() / 2];
                println!("Mul mid");
            });
        });
    });

    let mut expected = 0;
    expected += nums.iter().sum::<usize>();
    expected += nums.iter().filter(|n| *n % 2 == 0).sum::<usize>();
    expected *= nums.iter().max().unwrap();
    expected *= nums[nums.len() / 2];

    let n = *n.lock().unwrap();
    assert_eq!(n, expected);
    println!("{n} == {expected}");
}

pub fn join(&self)

Waits for all the jobs in the pool to finish

Examples found in repository

examples/example.rs (line 25)

pub fn main() {
    const N: i16 = 1024;
    let pool = ThreadPool::with_size(32).expect("Expected Ok value");
    let count = Arc::new(Mutex::new(0));

    let inc = |i: i16| {
        for _ in 0..N {
            let count = Arc::clone(&count);
            pool.execute(move || {
                let mut n = count.lock().unwrap();
                *n += i;
            })
        }
    };

    let check = |i: i16| {
        let n = count.lock().unwrap();
        assert_eq!(*n,i);
    };

    inc(1);
    pool.join();
    check(N);

    inc(-1);
    pool.join();
    check(0);
}

Trait Implementations

impl Default for ThreadPool

fn default() -> Self

Returns the “default value” for a type.

impl Drop for ThreadPool

fn drop(&mut self)

Executes the destructor for this type.