Add serial and parallel flavors of the async strategy

Author: Karthick Sankarachary

build.gradle

@@ -53,15 +53,9 @@ artifacts {
 
 allprojects {
     tasks.withType(Javadoc) {
-//        exclude('**/antlr/**')
     }
 
     tasks.withType(JavaCompile) {
-//        doFirst {
-//            if (sourceCompatibility == '1.6' && System.env.JDK6_HOME != null) {
-//                options.bootClasspath = "$System.env.JDK6_HOME/jre/lib/rt.jar"
-//            }
-//        }
     }
 
 }

src/main/java/graphql/async/GraphQL.java

@@ -30,7 +30,7 @@ public class GraphQL extends graphql.GraphQL {
    */
   public GraphQL(GraphQLSchema graphQLSchema) {
     //noinspection deprecation
-    this(graphQLSchema, new AsyncExecutionStrategy());
+    this(graphQLSchema, AsyncExecutionStrategy.parallel());
   }
 
 
@@ -44,7 +44,7 @@ public GraphQL(GraphQLSchema graphQLSchema) {
    */
   public GraphQL(GraphQLSchema graphQLSchema, ExecutionStrategy queryStrategy) {
     //noinspection deprecation
-    super(graphQLSchema, queryStrategy);
+    super(graphQLSchema, queryStrategy, AsyncExecutionStrategy.parallel());
   }
 
   /**
@@ -60,6 +60,7 @@ public GraphQL(GraphQLSchema graphQLSchema, ExecutionStrategy queryStrategy,
                  ExecutionStrategy mutationStrategy) {
     super(graphQLSchema, queryStrategy, mutationStrategy);
     assert queryStrategy instanceof AsyncExecutionStrategy;
+    assert mutationStrategy instanceof AsyncExecutionStrategy;
   }
 
   /**
@@ -75,8 +76,8 @@ public static Builder newAsyncGraphQL(GraphQLSchema graphQLSchema) {
   public static class Builder {
 
     private GraphQLSchema graphQLSchema;
-    private ExecutionStrategy queryExecutionStrategy = new SimpleExecutionStrategy();
-    private ExecutionStrategy mutationExecutionStrategy = new SimpleExecutionStrategy();
+    private ExecutionStrategy queryExecutionStrategy = AsyncExecutionStrategy.parallel();
+    private ExecutionStrategy mutationExecutionStrategy = AsyncExecutionStrategy.serial();
 
     public Builder(GraphQLSchema graphQLSchema) {
       this.graphQLSchema = graphQLSchema;

src/main/java/graphql/execution/AsyncExecutionStrategy.java

@@ -11,6 +11,7 @@
 import java.util.concurrent.ForkJoinPool;
 import java.util.function.Function;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import graphql.ExceptionWhileDataFetching;
 import graphql.ExecutionResult;
@@ -41,13 +42,31 @@
  */
 public class AsyncExecutionStrategy extends ExecutionStrategy {
 
-  ExecutorService executorService;
+  protected ExecutorService executorService;
+  protected boolean serial;
 
-  public AsyncExecutionStrategy() {
-    this(ForkJoinPool.commonPool());
+  public static AsyncExecutionStrategy serial() {
+    return new AsyncExecutionStrategy(true);
   }
 
-  public AsyncExecutionStrategy(ExecutorService executorService) {
+  public static AsyncExecutionStrategy serial(ExecutorService executorService) {
+    return new AsyncExecutionStrategy(true, executorService);
+  }
+
+  public static AsyncExecutionStrategy parallel() {
+    return new AsyncExecutionStrategy(false);
+  }
+
+  public static AsyncExecutionStrategy parallel(ExecutorService executorService) {
+    return new AsyncExecutionStrategy(false, executorService);
+  }
+
+  private AsyncExecutionStrategy(boolean serial) {
+    this(serial, ForkJoinPool.commonPool());
+  }
+
+  protected AsyncExecutionStrategy(boolean serial, ExecutorService executorService) {
+    this.serial = serial;
     this.executorService = executorService;
   }
 
@@ -68,7 +87,7 @@ public ExecutionResult execute(final ExecutionContext executionContext,
     Set<String> fieldNames = fields.keySet();
 
     // Create tasks to resolve each of the fields
-    fieldNames.stream().forEach((fieldName) -> {
+    (serial ? fieldNames.stream() : fieldNames.parallelStream()).forEach((fieldName) -> {
       fieldFutures.put(fieldName, CompletableFuture.supplyAsync(
         () -> resolveField(executionContext, parentType, source, fields.get(fieldName)),
         executorService));

src/test/groovy/graphql/execution/AsyncExecutionStrategyTest.groovy

@@ -64,7 +64,7 @@ class AsyncExecutionStrategyTest extends Specification {
                 new ThreadPoolExecutor.CallerRunsPolicy());
 
         def graphQL = GraphQL.newAsyncGraphQL(NewsSchema.newsSchema)
-                .queryExecutionStrategy(new AsyncExecutionStrategy(threadPoolExecutor))
+                .queryExecutionStrategy(AsyncExecutionStrategy.serial(threadPoolExecutor))
                 .build()
 
         def received = new AtomicReference<Map>()