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

Question

我在Codewars的问题中遇到了一个问题，它要求计算超级市场中自助结帐过程的客户队列的总时间，并要求使用线程池。所以，我只是谷歌搜索它，发现一个线程池模式由m个线程组成，它们被创建用于同时执行n个任务。对于目前的问题，我猜测线程将是结账亭的数量，任务的数量将等于客户的数量。下面是该问题的说明：

customers：表示队列的正整数数组。 每个整数表示一个客户，其值是他们需要检出的时间量。 n：一个正整数，结帐的数量。 该函数应该返回一个整数，即所需的总时间。

假设队列中的前端人员（即阵列/列表中的第一个元素） 一旦变为空闲状态就立即进入到队服。

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

我认为，解决方案需要随机拆分客户到自助结帐亭和计算需要多少时间来清理了所有那些使用线程队列。我发现下面提供了thread pool此示例代码：

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'); 
    } 

} 

如何使用上面的代码来计算的总时间？我也很感激任何其他建议。

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)); 
    } 
}