| use std::sync::mpsc; |
| use std::sync::Arc; |
| use std::sync::Mutex; |
| use std::thread; |
| |
| pub struct ThreadPool { |
| workers: Vec<Worker>, |
| sender: mpsc::Sender<Job>, |
| } |
| |
| // ANCHOR: here |
| // --snip-- |
| |
| type Job = Box<dyn FnOnce() + Send + 'static>; |
| |
| impl ThreadPool { |
| // --snip-- |
| // ANCHOR_END: here |
| /// Create a new ThreadPool. |
| /// |
| /// The size is the number of threads in the pool. |
| /// |
| /// # Panics |
| /// |
| /// The `new` function will panic if the size is zero. |
| pub fn new(size: usize) -> ThreadPool { |
| assert!(size > 0); |
| |
| let (sender, receiver) = mpsc::channel(); |
| |
| let receiver = Arc::new(Mutex::new(receiver)); |
| |
| let mut workers = Vec::with_capacity(size); |
| |
| for id in 0..size { |
| workers.push(Worker::new(id, Arc::clone(&receiver))); |
| } |
| |
| ThreadPool { workers, sender } |
| } |
| // ANCHOR: here |
| |
| pub fn execute<F>(&self, f: F) |
| where |
| F: FnOnce() + Send + 'static, |
| { |
| let job = Box::new(f); |
| |
| self.sender.send(job).unwrap(); |
| } |
| } |
| |
| // --snip-- |
| // ANCHOR_END: here |
| |
| struct Worker { |
| id: usize, |
| thread: thread::JoinHandle<()>, |
| } |
| |
| impl Worker { |
| fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker { |
| let thread = thread::spawn(|| { |
| receiver; |
| }); |
| |
| Worker { id, thread } |
| } |
| } |
| |
| fn main() {} |