Adds support for simple Executor

src/main/java/net/jodah/failsafe/FailsafeExecutor.java

@@ -345,7 +345,7 @@ public FailsafeExecutor<R> with(ScheduledExecutorService executor) {
    *
    * @throws NullPointerException if {@code executor} is null
    */
-  public FailsafeExecutor<R> with(ExecutorService executor) {
+  public FailsafeExecutor<R> with(Executor executor) {
     this.scheduler = Scheduler.of(executor);
     return this;
   }

src/main/java/net/jodah/failsafe/internal/util/DelegatingScheduler.java

@@ -37,14 +37,14 @@ public final class DelegatingScheduler implements Scheduler {
   private static volatile ForkJoinPool FORK_JOIN_POOL;
   private static volatile ScheduledThreadPoolExecutor DELAYER;
 
-  private final ExecutorService executorService;
+  private final Executor executor;
 
   private DelegatingScheduler() {
-    this.executorService = null;
+    this.executor = null;
   }
 
-  public DelegatingScheduler(ExecutorService executor) {
-    this.executorService = executor;
+  public DelegatingScheduler(Executor executor) {
+    this.executor = executor;
   }
 
   private static final class DelayerThreadFactory implements ThreadFactory {
@@ -108,9 +108,9 @@ private static ScheduledExecutorService delayer() {
     return DELAYER;
   }
 
-  private ExecutorService executorService() {
-    if (executorService != null)
-      return executorService;
+  private Executor executor() {
+    if (executor != null)
+      return executor;
     if (FORK_JOIN_POOL == null) {
       synchronized (DelegatingScheduler.class) {
         if (FORK_JOIN_POOL == null) {
@@ -128,12 +128,12 @@ private ExecutorService executorService() {
   @SuppressWarnings("unchecked")
   public ScheduledFuture<?> schedule(Callable<?> callable, long delay, TimeUnit unit) {
     ScheduledCompletableFuture promise = new ScheduledCompletableFuture<>(delay, unit);
-    ExecutorService es = executorService();
-    boolean isForkJoinPool = es instanceof ForkJoinPool;
+    Executor e = executor();
+    boolean isForkJoinPool = e instanceof ForkJoinPool;
     Callable<?> completingCallable = () -> {
       try {
         if (isForkJoinPool) {
-          // Guard against race with promise.cancel 
+          // Guard against race with promise.cancel
           synchronized (promise) {
             promise.forkJoinPoolThread = Thread.currentThread();
           }
@@ -151,16 +151,22 @@ public ScheduledFuture<?> schedule(Callable<?> callable, long delay, TimeUnit un
     };
 
     if (delay == 0)
-      promise.delegate = es.submit(completingCallable);
+      promise.delegate = submit(e, completingCallable);
     else
       promise.delegate = delayer().schedule(() -> {
         // Guard against race with promise.cancel
         synchronized (promise) {
           if (!promise.isCancelled())
-            promise.delegate = es.submit(completingCallable);
+            promise.delegate = submit(e, completingCallable);
         }
       }, delay, unit);
 
     return promise;
   }
+
+  private static <V> Future<V> submit(Executor executor, Callable<V> callable) {
+    FutureTask<V> future = new FutureTask<>(callable);
+    executor.execute(future);
+    return future;
+  }
 }

src/main/java/net/jodah/failsafe/util/concurrent/Scheduler.java

@@ -53,7 +53,7 @@ static Scheduler of(final ScheduledExecutorService executor) {
    *
    * @throws NullPointerException if {@code executor} is null
    */
-  static Scheduler of(final ExecutorService executor) {
+  static Scheduler of(final Executor executor) {
     return new DelegatingScheduler(Assert.notNull(executor, "executor"));
   }
 }