使用线程池计算所需的总时间

Question

I get struck in a problem in the Codewars that asks to calculate the total time for the customer queue for the self-checkout process in the supermarket and asked to use the concept of the thread pool. So, I just Googled it and find that a thread pool pattern consists of a number m of threads, created to perform a number n of tasks concurrently. For the current problem the I guess the threads will be the number of checkout booths and the number of the tasks will be equal to the number of the customers. Below are the instructions for the problem:

customers: an array of positive integers representing the queue. Each integer represents a customer, and its value is the amount of time they require to check out. n: a positive integer, the number of checkout tills. The function should return an integer, the total time required.

Assume that the front person in the queue (ie the first element in the array/list) proceeds to a till as soon as it becomes free.

public static int solveSuperMarketQueue(int[] customers, int n) {
  return 0;
}

I think the solution needs to be to split the customers randomly to the self-checkout booths and count how much time it takes to cleared up all those queues using the threading. I find this sample code for the thread pool provided below:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class WorkerThread implements Runnable {

    private String command;

    public WorkerThread(String s){
        this.command=s;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+' Start. Command = '+command);
        processCommand();
        System.out.println(Thread.currentThread().getName()+' End.');
    }

    private void processCommand() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString(){
        return this.command;
    }
}

public class SimpleThreadPool {

    public static void main(String[] args) {

        // I think this will be n in the provided method  
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // loop will iterate till **customers.length** time 
        for (int i = 0; i < 10; i++) {
            Runnable worker = new WorkerThread('' + i);
            executor.execute(worker);
          }
        executor.shutdown();
        while (!executor.isTerminated()) {
        }
        System.out.println('Finished all threads');
    }

}

How to use the above code to compute the total time ? I also appreciate any other suggestion.

Answer 1

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Solution {
    private final static long SCALE = 100L;
    static class Customer implements Callable<Void> {

        private final long timeToWait;
        private final CountDownLatch exitLatch;

        Customer(int timeToWait, CountDownLatch exitLatch) {
            this.timeToWait = timeToWait * SCALE;
            this.exitLatch = exitLatch;
        }

        @Override
        public Void call() throws Exception {
            Thread.sleep(this.timeToWait);
            this.exitLatch.countDown();
            return null;
        }
    }


    public static int solveSuperMarketQueue(int[] customers, int n) throws InterruptedException {
        ExecutorService service = Executors.newFixedThreadPool(n);
        CountDownLatch exitLatch = new CountDownLatch(n);
        Queue<Customer> queue = new LinkedList<>();
        for (int i : customers) {
            queue.add(new Customer(i, exitLatch));
        }

        long startTime = System.currentTimeMillis();
        service.invokeAll(queue);
        exitLatch.await();
        long wholeTime = System.currentTimeMillis() - startTime;
        service.shutdown();

        return (int) (wholeTime / SCALE + (wholeTime % SCALE == 0 ? 0 : 1));
    }
}