Completable Future Asynchronous Multithreading Framework (Part 2)

1. Create a completed Completable Future

This simple example creates a Completable Future with pre-set results that have been completed. Usually as the starting point of calculation.

static void completedFutureExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message");
    assertTrue(cf.isDone());
    assertEquals("message", cf.getNow(null));
}

The getNow method returns the completed result (message in this case) and the incoming default value null if it is not completed.

2. Run a simple asynchronous stage

The following example explains how to create a stage that runs Runnable asynchronously.

static void runAsyncExample() {
    CompletableFuture cf = CompletableFuture.runAsync(() -> {
        assertTrue(Thread.currentThread().isDaemon());
        randomSleep();
    });
    assertFalse(cf.isDone());
    sleepEnough();
    assertTrue(cf.isDone());
}

This example is intended to illustrate two things:

1. The method ending with Async in Completable Future will be executed asynchronously
2. By default (that is, in the absence of an Executor), asynchronous execution is implemented using ForkJoinPool, which uses a background thread to perform Runnable tasks. Note that this is only specific to the CompletableFuture implementation, and other ComppletableStage implementations can override the default behavior.

3. Act the method on the previous Stage

The following example refers to the Completable Future completed in the first example, which will refer to the generated string result and capitalize the string.

static void thenApplyExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message").thenApply(s -> {
        assertFalse(Thread.currentThread().isDaemon());
        return s.toUpperCase();
    });
    assertEquals("MESSAGE", cf.getNow(null));
}

The key word here is the nApply:

1. The "then" refers to the operation performed after the normal execution of the current phase (normal execution refers to the operation that does not throw an exception). In this case, the current phase is complete and the value message is obtained.
2. Apply is the result of applying a Function to a previous stage

Function is blocked, which means that the getNow() method is executed only after the uppercase operation is completed.

4. Asynchronously acting on the previous Stage

By adding the Async suffix after the method, the Completable Future chain will execute asynchronously (using ForkJoinPool.commonPool())

static void thenApplyAsyncExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(s -> {
        assertTrue(Thread.currentThread().isDaemon());
        randomSleep();
        return s.toUpperCase();
    });
    assertNull(cf.getNow(null));
    assertEquals("MESSAGE", cf.join());
}

Use a custom Executor to execute this method asynchronously

One advantage of the asynchronous approach is that it provides an Executor to execute Completable Stage. This example shows how to use a fixed size thread pool to achieve capitalization.

static ExecutorService executor = Executors.newFixedThreadPool(3, new ThreadFactory() {
    int count = 1;
    @Override
    public Thread newThread(Runnable runnable) {
        return new Thread(runnable, "custom-executor-" + count++);
    }
});
static void thenApplyAsyncWithExecutorExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(s -> {
        assertTrue(Thread.currentThread().getName().startsWith("custom-executor-"));
        assertFalse(Thread.currentThread().isDaemon());
        randomSleep();
        return s.toUpperCase();
    }, executor);
    assertNull(cf.getNow(null));
    assertEquals("MESSAGE", cf.join());
}

6. Consume the results of the previous Stage

If the next Stage receives the result of the current Stage but does not need to return a value (such as void) in the calculation, it will use the method thenAccept and pass it to a Consumer interface.

static void thenAcceptExample() {
    StringBuilder result = new StringBuilder();
    CompletableFuture.completedFuture("thenAccept message")
            .thenAccept(s -> result.append(s));
    assertTrue("Result was empty", result.length() > 0);
}

Consumer will execute synchronously, so we don't need to perform join operations on the returned Completable Future.

7. Asynchronous execution of Comsume

Similarly, the Asyn suffix is used to implement:

static void thenAcceptAsyncExample() {
    StringBuilder result = new StringBuilder();
    CompletableFuture cf = CompletableFuture.completedFuture("thenAcceptAsync message")
            .thenAcceptAsync(s -> result.append(s));
    cf.join();
    assertTrue("Result was empty", result.length() > 0);
}

8. Calculate when an anomaly occurs

Let's now simulate an exception scenario. For brevity, we'll capitalize a string, but we'll simulate a delay to do so. We will use thenApplyAsyn(Function, Executor), the first parameter is the capitalization method, and the second parameter is a delayed executor, which delays one second before submitting the operation to ForkJoinPool.

static void completeExceptionallyExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(String::toUpperCase,
            CompletableFuture.delayedExecutor(1, TimeUnit.SECONDS));
    CompletableFuture exceptionHandler = cf.handle((s, th) -> { return (th != null) ? "message upon cancel" : ""; });
    cf.completeExceptionally(new RuntimeException("completed exceptionally"));
    assertTrue("Was not completed exceptionally", cf.isCompletedExceptionally());
    try {
        cf.join();
        fail("Should have thrown an exception");
    } catch(CompletionException ex) { // just for testing
        assertEquals("completed exceptionally", ex.getCause().getMessage());
    }
    assertEquals("message upon cancel", exceptionHandler.join());
}

1. First, we create a new ComppletableFuture object that has been completed and has a return value message. Then we call the thenApplyAsync method, which returns a new CompletableFuture. This method performs capitalization in an asynchronous manner. It also shows how to use the delayed Executor (timeout, timeUnit) method to delay asynchronous operations.
2. Then we created a handler stage, exceptionHandler, which handles all exceptions and returns another message on cancel.
3. Finally, we explicitly complete the second stage and throw an exception, which causes a CompletionException to be thrown during the uppercase stage. It also triggers the handler phase.

9. Cancel Computation

Similar to exception handling in computation, we can cancel computation by Boolean mayInterruptIf Running in the Future interface.

static void cancelExample() {
    CompletableFuture cf = CompletableFuture.completedFuture("message").thenApplyAsync(String::toUpperCase,
            CompletableFuture.delayedExecutor(1, TimeUnit.SECONDS));
    CompletableFuture cf2 = cf.exceptionally(throwable -> "canceled message");
    assertTrue("Was not canceled", cf.cancel(true));
    assertTrue("Was not completed exceptionally", cf.isCompletedExceptionally());
    assertEquals("canceled message", cf2.join());
}

10. Act Function on one of the two completed Stage s

The following example creates a CompletableFuture object and acts on either of the completed two Stage s (there is no guarantee that either will be passed to Function). The two stages are as follows: one capitalizes the string and the other lowercase.

static void applyToEitherExample() {
    String original = "Message";
    CompletableFuture cf1 = CompletableFuture.completedFuture(original)
            .thenApplyAsync(s -> delayedUpperCase(s));
    CompletableFuture cf2 = cf1.applyToEither(
            CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayedLowerCase(s)),
            s -> s + " from applyToEither");
    assertTrue(cf2.join().endsWith(" from applyToEither"));
}

11. Either outcome of two stages of consumption

Similar to the previous example, replace Function with Consumer

static void acceptEitherExample() {
    String original = "Message";
    StringBuilder result = new StringBuilder();
    CompletableFuture cf = CompletableFuture.completedFuture(original)
            .thenApplyAsync(s -> delayedUpperCase(s))
            .acceptEither(CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayedLowerCase(s)),
                    s -> result.append(s).append("acceptEither"));
    cf.join();
    assertTrue("Result was empty", result.toString().endsWith("acceptEither"));
}

12. Runnable after both phases are completed

Note that both Stages run synchronously. After the first stage converts the string to uppercase, the second stage converts it to lowercase.

static void runAfterBothExample() {
    String original = "Message";
    StringBuilder result = new StringBuilder();
    CompletableFuture.completedFuture(original).thenApply(String::toUpperCase).runAfterBoth(
            CompletableFuture.completedFuture(original).thenApply(String::toLowerCase),
            () -> result.append("done"));
    assertTrue("Result was empty", result.length() > 0);
}

13. Receive the results of two stage s with Biconsumer

Biconsumer supports the simultaneous operation of the results of two Stage s.

static void thenAcceptBothExample() {
    String original = "Message";
    StringBuilder result = new StringBuilder();
    CompletableFuture.completedFuture(original).thenApply(String::toUpperCase).thenAcceptBoth(
            CompletableFuture.completedFuture(original).thenApply(String::toLowerCase),
            (s1, s2) -> result.append(s1 + s2));
    assertEquals("MESSAGEmessage", result.toString());
}

14. The effect of Bifunction on the results of two stages at the same time

If Completable Future wants to merge the results of two phases and return values, we can use the method thenCombine. The computational flow here is synchronous, so the final getNow() method will get the final result, that is, the splicing of the results of capitalization and lowercase operations.

static void thenCombineExample() {
    String original = "Message";
    CompletableFuture cf = CompletableFuture.completedFuture(original).thenApply(s -> delayedUpperCase(s))
            .thenCombine(CompletableFuture.completedFuture(original).thenApply(s -> delayedLowerCase(s)),
                    (s1, s2) -> s1 + s2);
    assertEquals("MESSAGEmessage", cf.getNow(null));
}

15. Asynchronous Bifunction acts on the results of two phases at the same time

Similar to the previous example, there is only a different approach here: the operation of both phases is asynchronous. Then the nCombine will also be executed asynchronously, even if it has no Async suffix.

static void thenCombineAsyncExample() {
    String original = "Message";
    CompletableFuture cf = CompletableFuture.completedFuture(original)
            .thenApplyAsync(s -> delayedUpperCase(s))
            .thenCombine(CompletableFuture.completedFuture(original).thenApplyAsync(s -> delayedLowerCase(s)),
                    (s1, s2) -> s1 + s2);
    assertEquals("MESSAGEmessage", cf.join());
}

16.Compose CompletableFuture

We can use thenCompose to do the first two examples.

static void thenComposeExample() {
    String original = "Message";
    CompletableFuture cf = CompletableFuture.completedFuture(original).thenApply(s -> delayedUpperCase(s))
            .thenCompose(upper -> CompletableFuture.completedFuture(original).thenApply(s -> delayedLowerCase(s))
                    .thenApply(s -> upper + s));
    assertEquals("MESSAGEmessage", cf.join());
}

17. When there is one completion in multiple phases, a new completion phase is created.

static void anyOfExample() {
    StringBuilder result = new StringBuilder();
    List messages = Arrays.asList("a", "b", "c");
    List<CompletableFuture> futures = messages.stream()
            .map(msg -> CompletableFuture.completedFuture(msg).thenApply(s -> delayedUpperCase(s)))
            .collect(Collectors.toList());
    CompletableFuture.anyOf(futures.toArray(new CompletableFuture[futures.size()])).whenComplete((res, th) -> {
        if(th == null) {
            assertTrue(isUpperCase((String) res));
            result.append(res);
        }
    });
    assertTrue("Result was empty", result.length() > 0);
}

18. When all phases are completed, create a new completion phase

static void allOfExample() {
    StringBuilder result = new StringBuilder();
    List messages = Arrays.asList("a", "b", "c");
    List<CompletableFuture> futures = messages.stream()
            .map(msg -> CompletableFuture.completedFuture(msg).thenApply(s -> delayedUpperCase(s)))
            .collect(Collectors.toList());
    CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]))
        .whenComplete((v, th) -> {
            futures.forEach(cf -> assertTrue(isUpperCase(cf.getNow(null))));
            result.append("done");
        });
    assertTrue("Result was empty", result.length() > 0);
}

19. When all phases are completed, create a new asynchronous completion phase

static void allOfAsyncExample() {
    StringBuilder result = new StringBuilder();
    List messages = Arrays.asList("a", "b", "c");
    List<CompletableFuture> futures = messages.stream()
            .map(msg -> CompletableFuture.completedFuture(msg).thenApplyAsync(s -> delayedUpperCase(s)))
            .collect(Collectors.toList());
    CompletableFuture allOf = CompletableFuture.allOf(futures.toArray(new CompletableFuture[futures.size()]))
            .whenComplete((v, th) -> {
                futures.forEach(cf -> assertTrue(isUpperCase(cf.getNow(null))));
                result.append("done");
            });
    allOf.join();
    assertTrue("Result was empty", result.length() > 0);
}

20. Real Scene

The following shows a scenario to practice Completable Future:

1. The Car list is obtained asynchronously by calling cars() method. It will return a Completion Stage < List < Car >. The cars() method should be implemented using a remote REST endpoint.
2. We combine the Stage with another Stage, and the other Stage asynchronously gets the ratings for each vehicle by calling rating(manufactureId).
3. When all Car objects are scored, we call allOf() to enter the final Stage, which will be executed after the completion of these two stages.
4. When Complete () is used in the final Stage to print out the vehicle score.

cars().thenCompose(cars -> {
    List<CompletionStage> updatedCars = cars.stream()
            .map(car -> rating(car.manufacturerId).thenApply(r -> {
                car.setRating(r);
                return car;
            })).collect(Collectors.toList());
    CompletableFuture done = CompletableFuture
            .allOf(updatedCars.toArray(new CompletableFuture[updatedCars.size()]));
    return done.thenApply(v -> updatedCars.stream().map(CompletionStage::toCompletableFuture)
            .map(CompletableFuture::join).collect(Collectors.toList()));
}).whenComplete((cars, th) -> {
    if (th == null) {
        cars.forEach(System.out::println);
    } else {
        throw new RuntimeException(th);
    }
}).toCompletableFuture().join();