Java 8 Completable Future

Question

My problem is how to use Completable Future.

I have a class that implements Callable.

public class Executor implements Callable<Collection>

Earlier is used to do -

service.submit(collectorService);

Which would return a Future<Collection>. However we don't want to use future anymore and need CompletableFuture . One idea is that we don't need to poll with CompletableFuture and We don't have to wait and block until it's ready.

So how would i use completable future and call a function say isDone() when the callable thread finishes.

Maybe interesting to you : http://stackoverflow.com/questions/23301598/transform-java-future-into-a-completablefuture — GPI, Mar 09 '15 at 13:34
“we don't want to use future anymore and need `CompletableFuture`”— interesting mix of “want” and “need”. Doesn’t sound like a rational decision to me… — Holger, Mar 09 '15 at 13:40
@Holger : agree with u. Should rephrase my words. We had implemented Future but seems the team that would consume our code does not want to do a poll of Future.isDone() and so would like us to supply CompletableFuture — ayush, Mar 09 '15 at 13:45

score 8 · Accepted Answer · answered Mar 09 '15 at 13:32

8

Given a CompletableFuture<T> f, you can kick off a synchronous or asynchronous task to run upon completion using:

f.thenApply(result -> isDone(result));      // sync callback
f.thenApplyAsync(result -> isDone(result)); // async callback

...or, if you don't need the result:

f.thenRun(() -> isDone());
f.thenRunAsync(() -> isDone());

answered Mar 09 '15 at 13:32

Mike Strobel

25,075
57
69

Sorry for asking more but how do i submit my Executor class objects inside the thenApply Functions. What does result object refer to here? – ayush Mar 09 '15 at 13:50
1

The `Consumer` passed to `thenAccept[Async]` is a callback which operates on the result of the task, so `result` refers to the result of the future `f`. In your original example, it would be a `Collection`. You can reference any `final` (or "effectively final") reference from your callback lamda, including your executor, if you want to submit another task in your callback. – Mike Strobel Mar 09 '15 at 13:59
1

thenApply is also async, the XXXAsync methods mean execute in a different thread. – Diego Ramos Jun 23 '21 at 07:50

score 2 · Answer 2 · answered Sep 18 '15 at 11:22

You can create a lambda expression that calls your existing collectorService. A Supplier lambda expression that CompletableFuture.supplyAsync will accept would look something like this

 Supplier<Collection> supplier = () -> collectorService.call();

And can be used with the CompletableFuture as follows

  CompletableFuture.supplyAsync(() -> collectorService.call(),service)
         .thenApply(collection->isDone(collection);

As others have pointed out the thenApply will be executed when the collectorService.call() method returns a result - on the same thread that performed our Future task. Using thenApplyAsync would resubmit another task to an executor service (raw performance is about an order of magnitude slower so don't do this unless you have a good reason too!).

score 1 · Answer 3 · answered Mar 09 '15 at 20:05

1

If I understand you correctly, you want to know how to submit a "task" (your previous "Executor") that gives back a CompletableFuture.

You do this by calling

CompletableFuture.supplyAsync(collectorService)

The difference is that your "Executor" must implement now Supplier instead of Callable

answered Mar 09 '15 at 20:05

Ruben

3,986
1
21
34

1

Yep, the collectorService could also be wrapped inside a Supplier lambda expression if changing the source wasn't an option. e.g. CompletableFuture.supplyAsync(() -> collectorService.call()) – John McClean Mar 11 '15 at 16:55
@JohnMcClean I think your comment is the best answer and I think you should make it an actual answer. – aalku Sep 18 '15 at 08:38
@aalku sure, added a specific answer with some more detail. – John McClean Sep 18 '15 at 11:35

sumit · Answer 4 · 2019-11-13T09:27:03.907

We don't pass runnable or callable in completableFuture. It takes supplier type which is a functional interface. Just create normal methods and pass them with the object of executor. For reference conside the below example .

package completableFuture;

import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompFuture {
    ExecutorService firstExecService = Executors.newFixedThreadPool(5);

    public static void main(String[] args) {

        CompFuture compFuture = new CompFuture();
        compFuture.testMe("Java");
    }

    public String m1(String param) {

        Random r = new Random();
        int val = r.nextInt(20) * 1000;
        System.out.println(Thread.currentThread().getName() + " " + val);

        try {
            Thread.sleep(val);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return param + " Hello my";
    }

    public void m2(String salutation) {
        System.out.println(Thread.currentThread().getName() + "  ##" + salutation + " Friend!");
    }

    public void testMe(String start) {
        System.out.println("TM: " + Thread.currentThread());

        for (int i = 0; i < 5; i++) {
            CompletableFuture.supplyAsync(() -> m1(start), firstExecService).thenAccept(s -> m2(s));
        }
    }

}

Output of above program:: Thread which takes min time to execute gives its output first.

TM: Thread[main,5,main]

pool-1-thread-1 1000

pool-1-thread-2 14000

pool-1-thread-4 3000

pool-1-thread-3 0

pool-1-thread-5 9000

pool-1-thread-3 ##Java Hello my Friend!

pool-1-thread-1 ##Java Hello my Friend!

pool-1-thread-4 ##Java Hello my Friend!

pool-1-thread-5 ##Java Hello my Friend!

pool-1-thread-2 ##Java Hello my Friend!

Java 8 Completable Future

4 Answers4