joist 1.0.0

A backend framework for Rust: routing, middleware, JSON, config and plugins, with no third-party dependencies.
Documentation
use std::sync::mpsc::{channel, Sender};
use std::sync::{Arc, Mutex};
use std::thread::{self, JoinHandle};

type Job = Box<dyn FnOnce() + Send + 'static>;

/// A fixed set of worker threads pulling from one queue.
///
/// Fixed rather than growing on demand: a pool that spawns a thread per
/// connection is a memory-exhaustion bug waiting for a slow-loris client. When
/// every worker is busy, new connections queue instead, which is a slower
/// server rather than a dead machine.
pub struct ThreadPool {
    workers: Vec<JoinHandle<()>>,
    sender: Option<Sender<Job>>,
}

impl ThreadPool {
    /// Panics if `size` is zero, since a pool with no workers accepts jobs and
    /// silently never runs them.
    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 {
                // A worker whose job panicked leaves the mutex poisoned. The
                // queue itself is still fine, so recover rather than taking the
                // whole pool down with it.
                let message = match rx.lock() {
                    Ok(guard) => guard.recv(),
                    Err(poisoned) => poisoned.into_inner().recv(),
                };
                match message {
                    Ok(job) => job(),
                    // The sender is gone, so no further work can arrive.
                    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) {
        // Dropping the sender ends every worker's recv loop; then wait for the
        // jobs already in flight rather than killing them mid-response.
        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);
                });
            }
            // Drop drains the queue before returning.
        }
        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);
    }
}