使用ExecutorCompletionService对不同的依赖项执行并发调用

Question

I am trying to use the ExecutorCompletionService - https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorCompletionService.html , to try and perform concurrent calls to two different dependent packages.

The reason I am using ExecutorCompletionService is because I want to compare the results returned by both the dependencies and then emit a metric based on a specific requirement.

My code looks like this:

@Builder
@Slf4j
public class TestClass {

    @NonNull private final ExecutorService threadPool = Executors.newFixedThreadPool(2);
    @NonNull private final ExecutorCompletionService<ResultStructure1> dependency1Thread = new ExecutorCompletionService<>(threadPool);
    @NonNull private final ExecutorCompletionService<ResultStructure2> dependency2Thread = new ExecutorCompletionService<>(threadPool);

    public void myMethod() {

        RequestObject1 firstDependencyRequest = RequestObject1.builder()
                .attribute1("someValue")
                .attribute2("secondValue");

        RequestObject2 secondDepdencyRequest = RequestObject1.builder()
                .attribute1("depdency2Value")
                .attribute2("depdency2Secondvalue");

        dependency1Thread.submit(() -> dependency1Client1.call(firstDependencyRequest));
        dependency2Thread.submit(() -> dependencyClient2.call(secondDepdencyRequest));

        final Future<ResultStructure1> future1 = dependency1Thread.take();
        final Future<ResultStructure2> future2 = dependency2Thread.take();
        try {
            ResultStructure1 = future1.get();
            ResultStructure2 = future2.get();
        } catch (ExecutionException e) {
            log.error("Exception calling dependency", e);
            throw e;
        }
    }
}

Is this the correct way to be using ExecutorCompletionService for different dependencies? Is there a way to have a single executorService and have both the dependencies be called from that?

Answer 1

Is this the correct way to be using ExecutorCompletionService for different dependencies?

Unfortunately, no. You'd typically use it to execute tasks returning similar type of results while you wait for their execution and their results to be available. Internally it uses a BlockingQueue where it adds the Future s as the tasks complete, which is then returned by its blocking take method.

So, if you do want to use an ExecutorCompletionService , you'd have to come up with a base/common type for ResultStructure1 and ResultStructure2 (ie, ResultStructure ), and declare a completion service like below -

private final ExecutorCompletionService<ResultStructure> completionService = 
    new ExecutorCompletionService<>(threadPool)

and then -

completionService.submit(() -> dependency1Client1.call(firstDependencyRequest));
completionService.submit(() -> dependencyClient2.call(secondDepdencyRequest));

You can then wait for their results to be available using the blocking take method -

Future<ResultStructure> result1 = completionService.take();
Future<ResultStructure> result2 = completionService.take();

Please note that at this point, we have no way of finding out which Future represents which concrete result type. So you have no way of comparing the results.

My recommendation would be to simply use ExecutorService directly.