import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class WorkerPool {
    // Here's the worker, of which we'll run several
    // concurrent instances. These workers will receive
    // work on the `jobs` queue and send the corresponding
    // results on `results`. We'll sleep a second per job to
    // simulate an expensive task.
    static class Worker implements Runnable {
        private int id;
        private BlockingQueue<Integer> jobs;
        private BlockingQueue<Integer> results;

        Worker(int id, BlockingQueue<Integer> jobs, BlockingQueue<Integer> results) {
            this.id = id;
            this.jobs = jobs;
            this.results = results;
        }

        public void run() {
            while (true) {
                try {
                    Integer j = jobs.poll(1, TimeUnit.SECONDS);
                    if (j == null) break;
                    
                    System.out.println("worker " + id + " started  job " + j);
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println("worker " + id + " finished job " + j);
                    results.put(j * 2);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        // In order to use our pool of workers we need to send
        // them work and collect their results. We make 2
        // queues for this.
        final int numJobs = 5;
        BlockingQueue<Integer> jobs = new LinkedBlockingQueue<>();
        BlockingQueue<Integer> results = new LinkedBlockingQueue<>();

        // This starts up 3 workers, initially blocked
        // because there are no jobs yet.
        for (int w = 1; w <= 3; w++) {
            Thread worker = new Thread(new Worker(w, jobs, results));
            worker.start();
        }

        // Here we send 5 `jobs` and then `close` that
        // queue to indicate that's all the work we have.
        for (int j = 1; j <= numJobs; j++) {
            jobs.put(j);
        }

        // Finally we collect all the results of the work.
        // This also ensures that the worker threads have
        // finished. An alternative way to wait for multiple
        // threads is to use a CountDownLatch.
        for (int a = 1; a <= numJobs; a++) {
            results.take();
        }
    }
}