Tech and Media Labs
This site uses cookies to improve the user experience.


Java Future

Jakob Jenkov
Last update: 2018-10-24

A Java Future, java.util.concurrent.Future, represents the result of an asynchronous computation. When the asynchronous task is created, a Java Future object is returned. This Future object functions as a handle to the result of the asynchronous task. Once the asynchronous task completes, the result can be accessed via the Future object returned when the task was started.

Some of Java's built-in concurrency utilities, like e.g. the Java ExecutorService, return a Java Future object from some of their methods. In the case of the ExecutorService, it returns a Future when you submit a Callable for it to execute concurrently (asynchronously).

Java Future Interface Definition

To understand how the Java Future interface works, here is an approximation of the interface definition:

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning)
    V       get();
    V       get(long timeout, TimeUnit unit);
    boolean isCancelled();
    boolean isDone();
}

Each of these methods will be covered in later sections - but as you can see, the Java Future interface is not that advanced.

Get Result From Future

As mentioned earlier, a Java Future represents the result of an asynchronous task. To obtain the result, you call one of the two get() methods on the Future. The get() methods both return an Object, but the return type can also be a generic return type (meaning an object of a specific class, and not just an Object). Here is an example of obtaining the result from a Java Future via its get() method:

Future future = ... // get Future by starting async task

// do something else, until ready to check result via Future

// get result from Future
try {
    Object result = future.get();
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

If you call the get() method before the asynchronous task has completed, the get() method will block until the result is ready.

There is a version of the get() method which can time out after an amount of time has passed which you can specify via method parameters. Here is an example of calling that get() version:

try {
    Object result =
        future.get(1000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {

} catch (ExecutionException e) {

} catch (TimeoutException e) {
    // thrown if timeout time interval passes
    // before a result is available.
}

The example above waits for a maximum of 1000 milliseconds for the result to be available in the Future. If no result is available within 1000 milliseconds, a TimeoutException is thrown.

Cancel Task via Future cancel()

You can cancel the asynchronous task represented by a Java Future instance by calling the Future cancel() method. The asynchronous task execution must be implemented in to support cancellation. Without such support, calling cancel() will have no effect. Here is an example of canceling a task via the Java Future cancel() method:

future.cancel();

Check if Task is Done

You can check if the asynchronous task is done (and a result available) by calling the Future isDone() method. Here is an example of calling the Java Future isDone() method:

Future future = ... // Get Future from somewhere

if(future.isDone()) {
    Object result = future.get();
} else {
    // do something else
}

Check if Task is Cancelled

It is also possible to check if the asynchronous task represented by a Java Future is cancelled. You check that by calling the Future isCancelled() method. Here is an example of checking if a task was cancelled:

Future future = ... // get Future from somewhere

if(future.isCancelled()) {

} else {

}

Jakob Jenkov




Copyright  Jenkov Aps
Close TOC