refactored TaskScheduler interface to use Futures instead of ForkJoinTasks

Author: mguenther

src/main/java/com/mgu/parallel/DefaultTaskScheduler.java renamed to src/main/java/com/mgu/parallel/ForkJoinTaskScheduler.java

@@ -7,15 +7,15 @@
 import java.util.concurrent.RecursiveTask;
 import java.util.function.Supplier;
 
-public class DefaultTaskScheduler implements TaskScheduler {
+public class ForkJoinTaskScheduler implements TaskScheduler {
 
     private final ForkJoinPool forkJoinPool;
 
-    public DefaultTaskScheduler() {
+    public ForkJoinTaskScheduler() {
         this(ForkJoinPool.commonPool());
     }
 
-    public DefaultTaskScheduler(final ForkJoinPool forkJoinPool) {
+    public ForkJoinTaskScheduler(final ForkJoinPool forkJoinPool) {
         this.forkJoinPool = forkJoinPool;
     }
 

src/main/java/com/mgu/parallel/Schedulers.java

@@ -1,20 +1,20 @@
 package com.mgu.parallel;
 
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.Future;
 import java.util.function.Supplier;
 
 /**
- * Provides some convenience methods to use the parallelization API of the {@link DefaultTaskScheduler}.
+ * Provides some convenience methods to use the parallelization API of the {@link ForkJoinTaskScheduler}.
  * This class relies on the {@code ForkJoinPool.commonPool()} for submitted {@code ForkJoinTask}s.
  *
  * @author Markus Günther (markus.guenther@gmail.com)
  */
 public class Schedulers {
 
-    private static final DefaultTaskScheduler SCHEDULER = new DefaultTaskScheduler();
+    private static final TaskScheduler SCHEDULER = new ForkJoinTaskScheduler();
 
-    private static <T> ForkJoinTask<T> task(final Supplier<T> body) {
+    private static <T> Future<T> task(final Supplier<T> body) {
         return SCHEDULER.schedule(body);
     }
 
@@ -27,10 +27,10 @@ public static <A, B, C, D> Tuple4<A, B, C, D> parallel(
             final Supplier<B> taskB,
             final Supplier<C> taskC,
             final Supplier<D> taskD) throws ExecutionException, InterruptedException {
-        final ForkJoinTask<A> ta = task(taskA);
-        final ForkJoinTask<B> tb = task(taskB);
-        final ForkJoinTask<C> tc = task(taskC);
-        final ForkJoinTask<D> td = task(taskD);
-        return new Tuple4<>(ta.join(), tb.join(), tc.join(), td.get());
+        final Future<A> ta = task(taskA);
+        final Future<B> tb = task(taskB);
+        final Future<C> tc = task(taskC);
+        final Future<D> td = task(taskD);
+        return new Tuple4<>(ta.get(), tb.get(), tc.get(), td.get());
     }
 }

src/main/java/com/mgu/parallel/TaskScheduler.java

@@ -1,6 +1,7 @@
 package com.mgu.parallel;
 
 import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.Future;
 import java.util.function.Supplier;
 
 /**
@@ -11,7 +12,7 @@
  */
 public interface TaskScheduler {
     /**
-     * Schedules the execution of the given {@code Supplier}. Yields a {@code ForkJoinTask} of parametric
+     * Schedules the execution of the given {@code Supplier}. Yields a {@code Future} of parametric
      * type {@code T}.
      *
      * @param body
@@ -20,23 +21,23 @@ public interface TaskScheduler {
      * @param <T>
      *      type of the result
      * @return
-     *      instance of {@code ForkJoinTask} that will eventually conclude with a result of type
+     *      instance of {@code Future} that will eventually conclude with a result of type
      *      {@code T}
      */
-    <T> ForkJoinTask<T> schedule(Supplier<T> body);
+    <T> Future<T> schedule(Supplier<T> body);
 
     /**
-     * Schedules the execution of the given {@code Runnable}. Yields a {@code ForkJoinTask} of parametric
+     * Schedules the execution of the given {@code Runnable}. Yields a {@code Future} of parametric
      * type {@code Void}. This variant of {@code schedule} should be used if the given {@code Runnable} closes
      * over its input data and the input data is the target as well.
      *
      * @param body
      *      a procedure that consumes no input arguments and returns no result either, scheduled for
      *      later execution
      * @return
-     *      instance of {@code ForkJoinTask} that will eventually conclude
+     *      instance of {@code Future} that will eventually conclude
      */
-    ForkJoinTask<Void> schedule(Runnable body);
+    Future<Void> schedule(Runnable body);
 
     /**
      * Executes both given {@code Supplier}s in parallel. Waits for termination of both and returns their