By default, ForkJoinPool executor takes a long time

I am working with CompletableFuture to asynchronously execute a stream generated from a list source.

so I am testing an overloaded method, ie "supplyAsync" CompletableFuture, where one method only takes one supplier parameter and the other takes a supplier parameter and an executor parameter. Here's the documentation for both:

one

supplyAsync (Supplier Supplier)

Returns a new CompletableFuture that is asynchronously completed by the task started in ForkJoinPool.commonPool () with the value returned by the call to this Provider.

second

supplyAsync (Vendor Supplier, Executor Executor)

Returns a new CompletableFuture that is completed asynchronously by the job running in this executor, with the value returned by calling this Provider.

And here is my test class:

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 millis\n", 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 millis\n", 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;
      }
    }

      

        
        
        
      

    

while the useCompletableFuture method takes about 4 seconds, the "useCompletableFutureWithExecutor" method takes only 1 second.

Not my question: What other processing does ForkJoinPool.commonPool () do that might cause overhead? In case we don't always prefer a custom executor pool over ForkJoinPool?