然后应用于CompletableFuture

Question

In the following code

public CompletableFuture<String> getMyFuture(String input)
    {   
        CompletableFuture<String> future = new CompletableFuture<String>().thenApply((result) -> result+ "::");
        ExecutorService service = Executors.newFixedThreadPool(6);
        service.submit(() -> {      
            try {
                future.complete(getResult(input));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        return future;
    }

    public String getResult(String input) throws InterruptedException
    {
        Thread.sleep(3000);
        return "hello "+ input +" :" + LocalTime.now();
    }

I am expecting the output to contain trailing "::" but program doesn't is "hello first :16:49:30.231 " Is my implementation of apply correct ?

Answer 1

You're invoking complete() method of the CompletionStage that you got at the first line (where you call "thenApply" method).

If your intention is to complete the CompletableFuture with some string value ( future.complete(getResult(input)) ) and then apply some function, you'd better place thenApply() at the end (where you return the future).

public CompletableFuture<String> getMyFuture(String input)
    {
        CompletableFuture<String> future = new CompletableFuture<String>();
        ExecutorService service = Executors.newFixedThreadPool(6);
        service.submit(() -> {
            try {
                future.complete(getResult(input));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        return future.thenApply(result -> result+ "::");
    }

I don't know how to explain it in a more understandable way. But in short: you're calling complete() method on the wrong object reference inside your Runnable .

Answer 2

You are creating two CompletableFuture instances. The first, created via new CompletableFuture<String>() will never get completed, you don't even keep a reference to it that would make completing it possible.

The second, created by calling .thenApply((result) -> result+ "::") on the first one, could get completed by evaluating the specified function once the first one completed, using the first's result as an argument to the function. However, since the first never completes, the function becomes irrelevant.

But CompletableFuture instances can get completed by anyone, not just a function passed to a chaining method. The possibility to get completed is even prominently displayed in its class name. In case of multiple completion attempts, one would turn out to be the first one, winning the race and all subsequent completion attempts will be ignored. In your code, you have only one completion attempt, which will successfully complete it with the value returned by getResult , without any adaptations.

You could change your code to keep a reference to the first CompletableFuture instance to complete it manually, so that the second gets completed using the function passed to thenApply , but on the other hand, there is no need for manual completion here:

public CompletableFuture<String> getMyFuture(String input) {   
    ExecutorService service = Executors.newFixedThreadPool(6);
    return CompletableFuture.supplyAsync(() -> getResult(input), service)
                            .thenApply(result -> result + "::");
}
public String getResult(String input) {
    LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(3));
    return "hello "+ input +" :" + LocalTime.now();
}    

When specifying the executor to supplyAsync , the function will be evaluated using that executor. More is not needed.

Needless to say, that's just for example. You should never create a temporary thread pool executor, as the whole point of a thread pool executor is to allow reusing the threads (and you're using only one of these six threads at all) and it should get shut down after use.