По умолчанию ForkJoinPool executor занимает много времени

Я работаю с CompletableFuture для асинхронного выполнения потока, генерируемого из источника списка.

Таким образом, я тестирую перегруженный метод, т. е. "supplyAsync" CompletableFuture, в котором один метод принимает только один параметр поставщика, а другой-параметр поставщика и параметр исполнителя.
Вот документация для обоих:

Один

SupplyAsync (поставщик поставщик)

Возвращает новый CompletableFuture, который асинхронно завершены задачи, работающей в ForkJoinPool.commonPool() со значением, полученным при вызове данного поставщика.

Второй

SupplyAsync (поставщик поставщик, исполнитель исполнитель)

Возвращает новую функцию CompletableFuture, асинхронно выполняемую задачей, запущенной в данном исполнителе, со значением, полученным при вызове данного поставщика.

А вот мой тестовый класс:

public class TestCompleteableAndParallelStream {



    public static void main(String[] args) {

        List<MyTask> tasks = IntStream.range(0, 10)

                .mapToObj(i -> new MyTask(1))

                .collect(Collectors.toList());



        useCompletableFuture(tasks);



        useCompletableFutureWithExecutor(tasks);



    }



    public static void useCompletableFutureWithExecutor(List<MyTask> tasks) {

          long start = System.nanoTime();

          ExecutorService executor = Executors.newFixedThreadPool(Math.min(tasks.size(), 10));

          List<CompletableFuture<Integer>> futures =

              tasks.stream()

                   .map(t -> CompletableFuture.supplyAsync(() -> t.calculate(), executor))

                   .collect(Collectors.toList());



          List<Integer> result =

              futures.stream()

                     .map(CompletableFuture::join)

                     .collect(Collectors.toList());

          long duration = (System.nanoTime() - start) / 1_000_000;

          System.out.printf("Processed %d tasks in %d millisn", tasks.size(), duration);

          System.out.println(result);

          executor.shutdown();

        }



    public static void useCompletableFuture(List<MyTask> tasks) {

          long start = System.nanoTime();

          List<CompletableFuture<Integer>> futures =

              tasks.stream()

                   .map(t -> CompletableFuture.supplyAsync(() -> t.calculate()))

                   .collect(Collectors.toList());



          List<Integer> result =

              futures.stream()

                     .map(CompletableFuture::join)

                     .collect(Collectors.toList());

          long duration = (System.nanoTime() - start) / 1_000_000;

          System.out.printf("Processed %d tasks in %d millisn", tasks.size(), duration);

          System.out.println(result);

        }







}





class MyTask {

      private final int duration;

      public MyTask(int duration) {

        this.duration = duration;

      }

      public int calculate() {

        System.out.println(Thread.currentThread().getName());

        try {

          Thread.sleep(duration * 1000);

        } catch (final InterruptedException e) {

          throw new RuntimeException(e);

        }

        return duration;

      }

    }

В то время как метод "useCompletableFuture" принимает около 4 секунд для завершения, метод "useCompletableFutureWithExecutor" занимает всего 1 секунду для завершения.

Нет, мой вопрос в том, какая разная обработка делает ForkJoinPool.commonPool (), который мог бы сделать накладные расходы? В том, что мы не всегда предпочитают выполненный исполнителем бассейн за ForkJoinPool?