use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};
type Job = Box<dyn FnOnce() + Send + 'static>;
pub struct ThreadPool {
workers: Vec<JoinHandle<()>>,
sender: Option<Sender<Job>>,
}
impl ThreadPool {
pub fn new(size: usize) -> ThreadPool {
assert!(size > 0, "a thread pool needs at least one worker");
let (sender, receiver) = channel::<Job>();
let receiver = Arc::new(Mutex::new(receiver));
let mut workers = Vec::with_capacity(size);
for _ in 0..size {
let rx = Arc::clone(&receiver);
workers.push(thread::spawn(move || loop {
let message = match rx.lock() {
Ok(guard) => guard.recv(),
Err(poisoned) => poisoned.into_inner().recv(),
};
match message {
Ok(job) => job(),
Err(_) => break,
}
}));
}
ThreadPool {
workers,
sender: Some(sender),
}
}
pub fn execute<F>(&self, job: F)
where
F: FnOnce() + Send + 'static,
{
if let Some(sender) = &self.sender {
let _ = sender.send(Box::new(job));
}
}
pub fn size(&self) -> usize {
self.workers.len()
}
}
impl Drop for ThreadPool {
fn drop(&mut self) {
drop(self.sender.take());
for worker in self.workers.drain(..) {
let _ = worker.join();
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::mpsc;
#[test]
fn runs_every_job() {
let counter = Arc::new(AtomicUsize::new(0));
{
let pool = ThreadPool::new(4);
for _ in 0..100 {
let c = Arc::clone(&counter);
pool.execute(move || {
c.fetch_add(1, Ordering::SeqCst);
});
}
}
assert_eq!(counter.load(Ordering::SeqCst), 100);
}
#[test]
fn spreads_work_across_workers() {
let pool = ThreadPool::new(3);
assert_eq!(pool.size(), 3);
let (tx, rx) = mpsc::channel();
for i in 0..3 {
let tx = tx.clone();
pool.execute(move || {
let _ = tx.send(i);
});
}
drop(tx);
let mut seen: Vec<i32> = rx.iter().collect();
seen.sort_unstable();
assert_eq!(seen, vec![0, 1, 2]);
}
#[test]
fn a_panicking_job_does_not_stop_the_pool() {
let counter = Arc::new(AtomicUsize::new(0));
{
let pool = ThreadPool::new(2);
pool.execute(|| panic!("boom"));
for _ in 0..10 {
let c = Arc::clone(&counter);
pool.execute(move || {
c.fetch_add(1, Ordering::SeqCst);
});
}
}
assert_eq!(counter.load(Ordering::SeqCst), 10);
}
}