Struct ThreadPool 

pub struct ThreadPool { /* private fields */ }

The thread pool of a lambda-channel that spawns threads running an infinite loop. The thread loop waits for a message from the input channel, executes a provided function, and sends the result to the output channel if the function has an output.

The pool starts with one control thread, all additional threads are normal worker threads. The control thread is identical to a normal worker thread, but also handles metrics collection, pool resizing, and termination propagation.

If the pool is dropped, the threads will automatically terminate. If the input channel or output channel to the thread pool disconnects, the threads will automatically terminate. If the thread is executing on an input or waiting to send an output when termination is triggered, it will finish execution and send the output value before terminating.

Implementations

impl ThreadPool

pub fn get_pool_size(&self) -> usize

Returns the target number of threads in the pool. The actual number of threads may temporarily differ when resizing the pool.

pub fn set_pool_size(&self, n: usize) -> Result<usize, ThreadPoolError>

Sets the target number of threads in the pool. The actual number of threads may temporarily differ when resizing the pool.

This function will return the desired thread size if successful, or a ThreadPoolError if not.

Examples found in repository

examples/channel_example.rs (line 56)

fn main() {
    let clock = quanta::Clock::new();
    let start = clock.now();

    let mut map: HashMap<char, AtomicU64> = HashMap::new();
    let mut all_alphanumeric: Vec<char> = Vec::new();
    all_alphanumeric.extend('0'..='9');
    all_alphanumeric.extend('a'..='z');
    all_alphanumeric.extend('A'..='Z');
    for char in all_alphanumeric {
        map.insert(char, AtomicU64::new(0));
    }
    let char_counts = Arc::new(map);

    let (tx, rx, thread_pool) = new_lambda_channel(None, None, char_counts.clone(), process_file);
    thread_pool.set_pool_size(4).unwrap();

    let files = vec![
        "./a.txt", "./b.txt", "./c.txt", "./d.txt", "./e.txt", "./f.txt",
    ];

    thread::spawn(move || {
        for file in files {
            tx.send(file).unwrap();
        }
    });

    while let Ok(msg) = rx.recv() {
        if let Err(e) = msg {
            println!("Failed to open file: {}", e);
        }
    }

    let mut total_counts: HashMap<char, u64> = HashMap::new();
    for (k, v) in char_counts.iter() {
        total_counts.insert(*k, v.load(Ordering::Relaxed));
    }

    println!("Execution Time: {:?}", start.elapsed());
    println!("{:?}", total_counts);
}

pub fn get_metrics(&self) -> Metrics

Returns the latest metric values, which is updated approx. every 10 seconds. Calling this function between updates, will return the same values.

Trait Implementations

impl Clone for ThreadPool

fn clone(&self) -> ThreadPool

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for ThreadPool

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

Formats the value using the given formatter.