use std::thread;
use std::sync::mpsc;
use std::time::Duration;

// Here's the worker, of which we'll run several
// concurrent instances. These workers will receive
// work on the `jobs` channel and send the corresponding
// results on `results`. We'll sleep a second per job to
// simulate an expensive task.
fn worker(id: i32, jobs: mpsc::Receiver<i32>, results: mpsc::Sender<i32>) {
    for job in jobs {
        println!("worker {} started  job {}", id, job);
        thread::sleep(Duration::from_secs(1));
        println!("worker {} finished job {}", id, job);
        results.send(job * 2).unwrap();
    }
}

fn main() {
    // In order to use our pool of workers we need to send
    // them work and collect their results. We make 2
    // channels for this.
    const NUM_JOBS: i32 = 5;
    let (jobs_sender, jobs_receiver) = mpsc::channel();
    let (results_sender, results_receiver) = mpsc::channel();

    // This starts up 3 workers, initially blocked
    // because there are no jobs yet.
    for w in 1..=3 {
        let jobs = jobs_receiver.clone();
        let results = results_sender.clone();
        thread::spawn(move || {
            worker(w, jobs, results);
        });
    }

    // Here we send 5 `jobs` and then `close` that
    // channel to indicate that's all the work we have.
    for j in 1..=NUM_JOBS {
        jobs_sender.send(j).unwrap();
    }
    drop(jobs_sender);

    // Finally we collect all the results of the work.
    // This also ensures that the worker threads have
    // finished.
    for _ in 1..=NUM_JOBS {
        results_receiver.recv().unwrap();
    }
}