Callable & Future Interfaces

A Callable is a generic interface, represents a thread which will return a value. It has a single method call() which throws Exception and returns an object of given type.

V call() throws Exception;

Callable is similar to Runnable with two major differences.

• Runnable task can not return a value while a Callable can.

• Callable can throw an exception while a Runnable can not.

A Callable must return a value if task is completed successfully or in case of failure an exception must be thrown.

ExecutorService#submit method accepts objects of type callable and execute them in their own threads.

Future

ExecutorService#submit returns an object of type Future which represents the result of Callable thread.

V get() throws InterruptedException, ExecutionException;

Future object can be queried for getting information about task cancellation or completion. The most important method of Future object is get() which returns the result of Callable object.

get() is a blocking a call and it stops the execution of current thread unless one of the following event occurs

• Current thread is interrupted (InterruptedException is thrown).

• Task is canceled (CancellationException is thrown).

or

• Task throws an exception (ExecutionException is thrown.)

Example

App.java

public class App {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ExecutorService es = Executors.newFixedThreadPool(2);

        Future<String> future = es.submit(() -> {
            System.out.println("waiting in " + Thread.currentThread().getName());
            Thread.sleep(3000);
            return "some random result";
        });

        System.out.println(future.get());

        es.shutdown();

    } // main

} // App

Output

waiting in pool-1-thread-1
some random result