Java MultiThread：意外的执行时间

Question

我目前正在检查 Java 中的多线程行为，但得到了意想不到的结果。

这就是我正在做的事情：

1. 生成 50 个随机邻接矩阵，大小为 600x600 和 将它们保存到 .txt 文件中
2. 读取这些矩阵并使用 N 运行 Floyd Warshall 算法 没有同步的线程（从 1 到 3）。每个线程运行 包含 50 个矩阵的算法。

这是我得到的结果（N 个线程的总执行时间）：

50 个 200x200 的矩阵：

• 有 1 个线程：~483 毫秒
• 有 2 个线程：~615 毫秒
• 3 个线程：~741 毫秒

50 个 600x600 的矩阵：

• 有 1 个线程：~9500 毫秒
• 有 2 个线程：~15389 毫秒
• 3 个线程：~16383 毫秒

50 个 1000x1000 的矩阵：

• 有 1 个线程：~43140 毫秒
• 有 2 个线程：~61408 毫秒
• 3 个线程：~76219 毫秒

1、2 或 3 个线程的时间不应该大致相同吗？ 为什么会增加？

这是运行 N 个线程的方法：

private static void runThreads(List<int[][]> graphs, int nThreads) throws InterruptedException {
    ExecutorService executor = Executors.newFixedThreadPool(nThreads);
    Collection<Callable<String>> callables = new ArrayList<Callable<String>>();

    for(int i = 0; i < nThreads; i++) {
        callables.add(new Callable<String>() {
            @Override
            public String call() throws Exception {
                for(int[][] graph: graphs) {
                    FloydWarshall f = new FloydWarshall(graph);
                    f.checkConsistency();
                }
                return null;
            }
        });
    }

    long startTime = System.currentTimeMillis();

    List<Future<String>> futures = executor.invokeAll(callables);

    executor.shutdown();

    long endTime   = System.currentTimeMillis();
    long totalTime = endTime - startTime;
    System.out.println("Total time: " + totalTime  + " ms");        
}

Answer 1

正如@C-Otto 在 cmets 中所说，您在多个线程上多次运行该任务：

for(int i = 0; i < nThreads; i++) { // <-- n threads are created
    System.out.println("Running thread #" + (i+1));
    executor.submit(new Runnable(){
        public void run(){
             for(int[][] graph: graphs) { // <-- operating on the whole list
                  FloydWarshall f = new FloydWarshall(graph);
                  f.checkConsistency();
             }
        }
    });         
}

因此，您在查看代码时看到的行为与预期的一样。因为您只是在创建n 线程，它们都同时执行整个列表。执行时间的缺点来自 JVM 必须处理的额外负载（例如，创建一个新线程、执行整个算法等等）。

但您可能想要平衡n 线程上的负载，因此每个线程只处理整体的一小部分 (1/nth)。

因此您可能需要定义一些逻辑来拆分源（例如Spliterator、ForkJoinPool 或Streams），然后再次测量时间。