Skip to content
Related Articles
Get the best out of our app
Open App

Related Articles

Future and FutureTask in java

Improve Article
Save Article
Like Article
Improve Article
Save Article
Like Article

Prerequisite: Future and callable


A Future interface provides methods to check if the computation is complete, to wait for its completion and to retrieve the results of the computation. The result is retrieved using Future’s get() method when the computation has completed, and it blocks until it is completed. 
Future and FutureTask both are available in java.util.concurrent package from Java 1.5.


  1. FutureTask is a concrete implementation of the Future, Runnable, and RunnableFuture interfaces and therefore can be submitted to an ExecutorService instance for execution.
  2. When calling ExecutorService.submit() on a Callable or Runnable instance, the ExecutorService returns a Future representing the task. and one can create it manually also.
  3. FutureTask acts similar to a CountDownLatch when calling get() in that it waits for the task to complete or error out.
  4. Behaviour of the parameterless get() method depends on the state of the task. If tasks are not completed, get() method blocks until the task is completed. Once the task complete, it returns the result or throws an ExecutionException.
  5. An overloaded variant of get() allows passing a timeout parameter to limit the amount of time the thread waits for a result.

Example:  When submitting a FutureTask instance to a thread pool (ExecutorService instance) , it returns a Future object immediately. This Future object can be used for task completion and getting result of computation asynchronously. 

Examples: Create two task. After one is completely executed, then after waiting 2000 millisecond, second task is being executed

Note: Online IDE does not work properly on sleep() method. 


// Java program do two FutureTask
// using Runnable Interface
import java.util.concurrent.*;
import java.util.logging.Level;
import java.util.logging.Logger;
class MyRunnable implements Runnable {
    private final long waitTime;
    public MyRunnable(int timeInMillis)
        this.waitTime = timeInMillis;
    public void run()
        try {
            // sleep for user given millisecond
            // before checking again
            // return current thread name
        catch (InterruptedException ex) {
                .log(Level.SEVERE, null, ex);
// Class FutureTaskExample execute two future task
class FutureTaskExample {
    public static void main(String[] args)
        // create two object of MyRunnable class
        // for FutureTask and sleep 1000, 2000
        // millisecond before checking again
        MyRunnable myrunnableobject1 = new MyRunnable(1000);
        MyRunnable myrunnableobject2 = new MyRunnable(2000);
            futureTask1 = new FutureTask<>(myrunnableobject1,
                                           "FutureTask1 is complete");
            futureTask2 = new FutureTask<>(myrunnableobject2,
                                           "FutureTask2 is complete");
        // create thread pool of 2 size for ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // submit futureTask1 to ExecutorService
        // submit futureTask2 to ExecutorService
        while (true) {
            try {
                // if both future task complete
                if (futureTask1.isDone() && futureTask2.isDone()) {
                    System.out.println("Both FutureTask Complete");
                    // shut down executor service
                if (!futureTask1.isDone()) {
                    // wait indefinitely for future
                    // task to complete
                    System.out.println("FutureTask1 output = "
                                       + futureTask1.get());
                System.out.println("Waiting for FutureTask2 to complete");
                // Wait if necessary for the computation to complete,
                // and then retrieves its result
                String s = futureTask2.get(250, TimeUnit.MILLISECONDS);
                if (s != null) {
                    System.out.println("FutureTask2 output=" + s);
            catch (Exception e) {
                System.out.println("Exception: " + e);


FutureTask1 output = FutureTask1 is complete
Waiting for FutureTask2 to complete
Exception: java.util.concurrent.TimeoutException
Waiting for FutureTask2 to complete
Exception: java.util.concurrent.TimeoutException
Waiting for FutureTask2 to complete
Exception: java.util.concurrent.TimeoutException
Waiting for FutureTask2 to complete
FutureTask2 output=FutureTask2 is complete
Both FutureTask Complete



My Personal Notes arrow_drop_up
Last Updated : 08 Feb, 2023
Like Article
Save Article
Related Tutorials