bug (delay == 0); fix bad commonPool() as executor; use less memory: …

…don't capture variable with commonPool

core/src/main/java/dev/failsafe/internal/util/DelegatingScheduler.java

@@ -50,8 +50,11 @@ private DelegatingScheduler() {
     this.executorService = null;
   }
 
-  public DelegatingScheduler(ExecutorService executor) {
-    this.executorService = executor;
+  public DelegatingScheduler(ExecutorService executor){
+    if (executor != ForkJoinPool.commonPool() || useCommonPool())
+      this.executorService = executor;
+    else // don't use commonPool(): cannot support parallelism @see CompletableFuture#useCommonPool
+      this.executorService = null;
   }
 
   private static final class LazyDelayerHolder {
@@ -75,14 +78,17 @@ private static final class LazyForkJoinPoolHolder {
     private static final ForkJoinPool FORK_JOIN_POOL = create();
 
     private static ForkJoinPool create(){
-      return ForkJoinPool.getCommonPoolParallelism() > 1
-          ? ForkJoinPool.commonPool()
+      return useCommonPool() ? ForkJoinPool.commonPool()
           : new ForkJoinPool(Math.max(Runtime.getRuntime().availableProcessors(), 2),
               ForkJoinPool.defaultForkJoinWorkerThreadFactory,
               null, true);
     }
   }
 
+  static boolean useCommonPool () {
+    return ForkJoinPool.getCommonPoolParallelism() > 1;
+  }
+
   static final class ScheduledCompletableFuture<V> extends CompletableFuture<V> implements ScheduledFuture<V> {
     // Guarded by this
     volatile Future<V> delegate;
@@ -159,12 +165,22 @@ public ScheduledFuture<?> schedule(Callable<?> callable, long delay, TimeUnit un
       return null;
     };
 
-    if (delay == 0)
+    if (delay <= 0)
       promise.delegate = es.submit(completingCallable);
+
+    // use less memory: don't capture variable with commonPool
+    else if (es == LazyForkJoinPoolHolder.FORK_JOIN_POOL)
+      promise.delegate = delayer().schedule(()->{
+        // Guard against race with promise.cancel
+        synchronized(promise) {
+          if (!promise.isCancelled())
+            promise.delegate = LazyForkJoinPoolHolder.FORK_JOIN_POOL.submit(completingCallable);
+        }
+      }, delay, unit);
     else
-      promise.delegate = delayer().schedule(() -> {
+      promise.delegate = delayer().schedule(()->{
         // Guard against race with promise.cancel
-        synchronized (promise) {
+        synchronized(promise) {
           if (!promise.isCancelled())
             promise.delegate = es.submit(completingCallable);
         }