java - ExecutorService.submit() 需要更多时间？

Question

我试图了解 java.util.concurrent 包中的实用程序，并了解到我们可以将 callable 对象提交给 ExecutorService，在 call() 方法内成功完成任务后，返回 Future，其中填充了 callable 返回的值。

我了解到所有可调用项都是使用多个线程同时执行的。

当我想看看 ExecutorService 对批处理任务执行有多大改进时，我想到了捕获时间。

以下是我尝试执行的代码 -

package concurrency;


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;


public class ExecutorExample {

    private static Callable<String> callable = new Callable<String>() {

        @Override
        public String call() throws Exception {
            StringBuilder builder = new StringBuilder();
            for(int i=0; i<5; i++) {
                builder.append(i);
            }
            return builder.toString();
        }
    };

    public static void main(String [] args) {
        long start = System.currentTimeMillis();
        ExecutorService service = Executors.newFixedThreadPool(5);
        List<Future<String>> futures = new ArrayList<Future<String>>();
        for(int i=0; i<5; i++) {
            Future<String> value = service.submit(callable);
            futures.add(value);
        }
        for(Future<String> f : futures) {
            try {
                System.out.println(f.isDone() + " " + f.get());
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (ExecutionException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        long end  = System.currentTimeMillis();
        System.out.println("Executer callable time - " + (end - start));
        service.shutdown();

        start = System.currentTimeMillis();
        for(int i=0; i<5; i++) {
            StringBuilder builder = new StringBuilder();
            for(int j=0; j<5; j++) {
                builder.append(j);
            }
            System.out.println(builder.toString());
        }
        end = System.currentTimeMillis();
        System.out.println("Normal time - " + (end - start));
    }

}

这是这个的输出 -

true 01234
true 01234
true 01234
true 01234
true 01234
Executer callable time - 5
01234
01234
01234
01234
01234
Normal time - 0

如果我遗漏了什么或以错误的方式理解了某些东西，请告诉我。

在此先感谢您抽出宝贵的时间和对本主题的帮助。

Answer 1

如果 Callable 中的任务太小，由于任务切换和初始化开销，您将无法从并发中获益。尝试在 callable 中添加更重的循环，比如 1000000 次迭代，您会看到差异