Question

我有以下示例代码。

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多线程。

Answer 1

Future＃get block，直到你的callable完成。因此主线程将一个Callable提交给池，然后等待它完成，然后再提交下一个。你有创建池的四个线程的开销，然后你在创建callables的线程和对象创建之间进行上下文切换（垃圾收集要在callables被丢弃时完成），那么你没有做任何同时工作。

如何获得使用池的版本更快的数字令人费解。当我在本地运行这个（并且做好MVCE，顺便说一下，我可以复制粘贴而不做任何更改并且它有效）我得到的线程部分的数字一直更高，它需要的时间大约是单个的3倍线程代码。

Java Callable：超过单个线程进程所花费的时间

1 个答案: