Java Future Example

In Java, Future is an interface that belongs to java.util.concurrent package. It is used to represent the result of an asynchronous computation. The interface provides the methods to check if the computation is completed or not, to wait for its completion, and to retrieve the result of the computation. Once the task or computation is completed one cannot cancel the computation.

Syntax:

Example of Java Future

The best example of Java Future is ExecutorService interface. It produces a Future (from some of their methods) object for tracking progress of one or more asynchronous task.

Methods of the Future Interface

The interface provides the following five methods:

Method	Description
cancel()	It tries to cancel the execution of the task.
get()	The method waits if necessary, for the computation to complete, and then retrieves its result.
get()	Waits if necessary, for at most the given time for the computation to complete, and then retrieves its result, if available.
isCancelled()	It returns true if the task was cancelled before its completion.
isDone()	It returns true if the task is completed.

There was some shortcoming of the Future interface that are as follows:

Using Future, the computation cannot be completed manually.
It does not notify once the commutation is completed.
Its chain cannot be created and combined.

In order to overcome the above limitations, Java 8 introduced CompletableFuture.

Using Future in Asynchronous Programming

Getting Result

As we have discussed above, the Future represents the result of an asynchronous task. In order to retrieve the result of that asynchronous task, the Java Future interface provides the following two versions of the get() methods both return an object. Note that the return type may be a generic type. For example:

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();
}

Note: If we try to invoke the get() method before the asynchronous task is completed, the get() method will block until the result is ready.

In order to overcome the above shortcoming, the Future interface provides another version of the get() method that excepts an amount of time (in milliseconds) as a parameter. It represents that the Future will wait for an amount of time to complete the task after that result will be available in the Future. For example:

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.
}

If Future does not get any result within the specified time, a TimeoutException is thrown by the Future.

Cancel an Asynchronous Task

We can also cancel an asynchronous task at any point by calling the cancel() method of the Future interface. For example:

Future future = ... // Get Future from somewhere
future.cancel();

Check if an Asynchronous Task is Done

The interface provides a method isDone() to check if the asynchronous task is completed or not. For example:

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

Check if an Asynchronous Task is Cancelled

The Future interface provides a method isCancelled() to check if the asynchronous task represented by Future is cancelled or not. It returns true if the task is cancelled successfully, else returns false. For example:

Future future = ... // get Future from somewhere
if(future.isCancelled()) 
{
} 
else 
{
}

Example of Java Future

FutureExample.java

import java.util.concurrent.*;
public class FutureExample 
{
public static void main(String args[]) throws InterruptedException, ExecutionException 
{
//ExecutorService allows us to execute tasks on threads asynchronously    
ExecutorService es = Executors.newSingleThreadExecutor();
//getting future
//the method submit() submits a value-returning task for execution and returns the Future
Future<String> future = es.submit(() -> 
{
//sleep thread for 2 seconds    
Thread.sleep(2000);
return "Welcome to Javatpoint";
});
//checks if the task is completed or not
while(!future.isDone()) 
{
System.out.println("The task is still in process.....");
//sleep thread for 2 milliseconds    
Thread.sleep(200);
}
System.out.println("Task completed! getting the result");
//getting the result after completing the task
String result = future.get();
//prints the result 
System.out.println(result);
es.shutdown();
}
}

Output: