2

我有以下示例代码。

import java.util.*;
import java.lang.*;
import java.io.*;

import java.util.concurrent.*;
public class CalculationThread implements Callable<Long> {

    public Long call() throws Exception {
        long k=0L;
        for(int i=0;i<100000;i++){
            for(int j=0;j<50;j++){
                k=i+j;
            }
        }
        return k;
    }
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(4);
        long startTime = System.nanoTime();
        for(int lo=0;lo<5000;lo++){
            Future<Long> result = executorService.submit(new CalculationThread());

            try {
                Long l = result.get();
            } catch (Exception e) {
                result.cancel(true);
            }

        }
        long endTime = System.nanoTime();
        System.out.println("Using threads took "+(endTime - startTime) + " ns");

        executorService.shutdown();
        executorService.awaitTermination(1, TimeUnit.SECONDS);

        long k=0L;
        startTime = System.nanoTime();
        for(int lo=0;lo<5000;lo++){
            for(int i=0;i<100000;i++){
                for(int j=0;j<50;j++){
                    k=i+j;
                }
            }

        }
        endTime = System.nanoTime();
        System.out.println("Generally it takes "+(endTime - startTime) + " ns");

    }
}

输出分布为

Using threads took 101960490 ns
Generally it takes 143107865 ns

至

Using threads took 245339720 ns
Generally it takes 149699885 ns

可以注意到第二行几乎是不变的，而线程版本变化很大。为什么会出现这种情况？可以做些什么来减少变异性？请让我知道我是否在做一些愚蠢的事情，因为我是 Java 多线程的新手。

4

1 回答 1

1

Future#get 阻塞，直到您的可调用对象完成。所以主线程向池提交一个 Callable，然后等待它完成，然后再提交下一个。您有创建池的四个线程的开销，然后您在线程和创建可调用对象的对象创建之间进行上下文切换（在可调用对象被丢弃时进行垃圾收集），然后您没有做任何工作同时进行。

您如何获得使用池的版本更快的数字令人费解。当我在本地运行它时（并且很好地制作了一个 MVCE，顺便说一句，我可以复制和粘贴而不做任何更改并且它可以工作）我得到线程池部分的数字始终更高，它需要大约 3 倍于单线程代码。

于 2015-08-05T19:27:33.607 回答