如何计算多线程进程的总计算时间

Question

我有一组任务，我们称之为T[]，其中每个任务T[i] 需要一定的时间t(T[i]) 来处理。这些任务由X线程并行处理（这并不是说多个线程在一个任务上协同工作，而是多个任务由多个线程处理，每个线程执行一个任务，然后执行下一个任务， ETC）。

现在我想计算处理所有任务所需的预期总时间。当然只要size(T[]) <= X就很简单（即任务数小于等于线程数），这种情况下总时间等于最慢任务的时间。

但我对X < size(T[]) 的情况感到很困惑（即我的线程比任务少）。如何以一种优雅的方式计算？

编辑：根据评论员的要求，我们可以假设任务队列按运行时间最长的任务在前排序，运行时间最短的任务在后。此外，我们可以假设任务之间没有暂停，我们也可以忽略 OS 调度程序正在做什么。

Answer 1

我假设任务是按照提供的顺序安排的，并且每个任务都会转到第一个空闲的线程。如果这些假设是正确的，则没有有意义的不确定性——一个任务可能会转到任何空闲的线程（如果有多个线程），但这对总运行时间没有影响。

在这种情况下，我们可以使用大小为 X（其中 X 是线程数）的最小堆来模拟这种情况，堆中的值表示其中一个线程的空闲时间。对于每个任务，我们将最早空闲的线程从堆中弹出，然后在完成新任务的时间将其推回。

在我们调度完所有任务后，我们可以取堆中的最大值，这将是所有任务完成的时间。

这是 Python 中相对较少的代码：

import heapq

def compute_time(tasks, X):
    threads = [0] * X
    for t in tasks:
        heapq.heappush(threads, heapq.heappop(threads) + t)
    return max(threads)

print compute_time([3, 2, 1], 2)
print compute_time([5, 4, 3, 3, 2, 1, 1], 3)

或者在 Java 中：

import java.util.*;

class Threads {
    public static void main(String args[]) {
        int totalTime1 = computeTotalTime(Arrays.asList(3, 2, 1), 2);
        System.out.println("totalTime1: " + totalTime1);

        int totalTime2 = computeTotalTime(Arrays.asList(5, 4, 3, 3, 2, 1, 1), 3);
        System.out.println("totalTime2: " + totalTime2);
    }

    static int computeTotalTime(List<Integer> task, int threads) {
        PriorityQueue<Integer> q = new PriorityQueue<Integer>();
        for (int i = 0; i < threads; i++) q.add(0);
        for (int t : task) q.add(q.poll() + t);
        int max = 0;
        while(!q.isEmpty()) max = q.poll();
        return max;
    }
}

Answer 2

当执行顺序（大致）确定时，模拟测试运行是解决方案。我只是拿了我真正的处理代码，并用一个简单的 Thread.sleep 替换它，同时休眠了任务预计需要处理的时间（只是解释为毫秒来缩小它）。最后，我只是再次放大了它所花费的时间，结果相当不错。我在 5 个线程上运行了近 100 个执行时间差异很大的任务。估计用时 1 小时 39 分钟，实际运行时间只差 3 分钟。

            long startSim = currentTimeMillis();
            List<Integer> taskTimes = parallelTests.getRuntimesForAllTests(); // ordered from longest time
            ThreadPoolExecutor simulationExecutor = (ThreadPoolExecutor) Executors.newFixedThreadPool(threadCount);
            taskTimes.forEach(taskTime -> simulationExecutor.submit(() -> {
                try {
                    Thread.sleep(taskTime); // this is really seconds, but we just take it as milliseconds
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }));
            simulationExecutor.shutdown();
            simulationExecutor.awaitTermination(1, MINUTES);
            long stopSim = currentTimeMillis();
            long timeNeeded = stopSim - startSim;
            // now just multiply it *1000 to scale it up to seconds again, and that's your result