How to use Future and FutureTask in Java Concurrency with Example

Future and FutureTask in Java allows you to write asynchronous code. Future is a general concurrency abstraction, also known as a promise, which promises to return a result in future. In asynchronous programming, main thread doesn't wait for any task to finished, rather it hand over the task to workers and move on. One way of asynchronous processing is using callback methods. Future is another way to write asynchronous code. By using Future and FutureTask, you can write a method which does long computation but returns immediately. Those methods, instead of returning a result, return a Future object. You can later get the result by calling Future.get() method, which will return an object of type T, where T is what Future object is holding.


One example of Future is submit() method of ExecutorService, which immediately return a Future object. By the way, Future and FutureTask are available in java.util.concurrent package from Java 1.5. Also, Future is and interface and FutureTask is an implementation or RunnableFuture, which can be used as a Runnable interface, thus, can be passed to ExecutorService.

In this Java concurrency tutorial, we will learn how to use Future and FutureTask in Java.



Future and FutureTask Example - Java

One of the simplest examples of using Future is working with Thread pools. When you submit a long running task to ExecutorService, it returns a Future object immediately. This Future object can be used to query task completion and getting result of computation. In our sample Java program, we have a created a FactorialCalculator task, which wraps calculation of factorial under Callable interface's call() method.

When we submit this task with job of calculating factorial of a huge number like 100000, ExecutorService returns a Future object, which holds long value, return type of call method in our case. Later, we check whether task is completed or not using isDone() method. From output, you can see that main thread returns immediately. Since we have used get() method once task is completed, it doesn't block and return result immediately.

By the way, Future object returned by the submit() method is also an instance of FutureTask.

Future and FutureTask Example in Java Concurrency




Sample Java Program to use Future and FutreTask
Here is our simple test program, which demonstrate how you can use these two classes to do asynchronous execution in Java. First we have created a FutureTask which is nothing but a nested static class which implements Callable interface. In this method we call our factorial method to calculate factorial of a number. To make this method long-running, we have also introduced a small sleep duration. This will help you to better understand how Future works.

package test;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Java program to show how to use Future in Java. Future allows to write
 * asynchronous code in Java, where Future promises result to be available in
 * future
 *
 * @author Javin
 */
public class FutureDemo {

    private static final ExecutorService threadpool = Executors.newFixedThreadPool(3);

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

        FactorialCalculator task = new FactorialCalculator(10);
        System.out.println("Submitting Task ...");

        Future future = threadpool.submit(task);

        System.out.println("Task is submitted");

        while (!future.isDone()) {
            System.out.println("Task is not completed yet....");
            Thread.sleep(1); //sleep for 1 millisecond before checking again
        }

        System.out.println("Task is completed, let's check result");
        long factorial = future.get();
        System.out.println("Factorial of 1000000 is : " + factorial);

        threadpool.shutdown();
    }

    private static class FactorialCalculator implements Callable {

        private final int number;

        public FactorialCalculator(int number) {
            this.number = number;
        }

        @Override
        public Long call() {
            long output = 0;
            try {
                output =  factorial(number);
            } catch (InterruptedException ex) {
                Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
            }
            
            return output;
        }

        private long factorial(int number) throws InterruptedException {
            if (number < 0) {
                throw new IllegalArgumentException("Number must be greater than zero");
            }
            long result = 1;
            while (number > 0) {
                Thread.sleep(1); // adding delay for example
                result = result * number;
                number--;
            }
            return result;
        }
    }

}

Output
Submitting Task ...
Task is submitted
Task is not completed yet....
Task is not completed yet....
Task is not completed yet....
Task is completed, let's check result
Factorial of 1000000 is : 3628800

You can see that because of the sleep() method we have introduced in factorial method, it took some time to finish and during that time isDone() method returned false. This is why you are seeing the output "Task is not completed yet". Once task is completed the result is available as Future object.

See Core Java for Inpatients to learn more about how to use concurrency classes in Java Program.

How to use Future and FutureTask in Java



Important points Future and FutureTask  in Java

Now we have learned how to use Future and FutureTask in Java program. Let's revise some key points about Future concept and FutureTask class in Java itself.

1. Future is a base interface and defines abstraction of an object which promises result to be available in future while FutureTask is an implementation of the Future interface.

2. Future is a parametric interface and type-safe written as Future<V>, where V denotes value.

3. Future provides get() method to get result, which is blocking method and blocks until result is available to Future.

4. Future interface also defines cancel() method to cancel task.

5. isDone() and isCancelled() method is used to query Future task states. isDone() returns true if task is completed and result is available to Future. If you call get() method, after isDone() returned true then it should return immediately. On the other hand, isCancelled() method returns true, if this task is cancelled before its completion.

6. Future has four sub interfaces, each with additional functionality e.g. Response, RunnableFuture, RunnableScheduledFuture and ScheduledFuture. RunnableFuture also implements Runnable and successful finish of run() method cause completion of this Future.


7. FutureTask and SwingWorker are two well known implementation of Future interface. FutureTask also implements RunnableFuture interface, which means this can be used as Runnable and can be submitted to ExecutorService for execution.


8. Though most of the time ExecutorService creates FutureTask for you, i.e. when you submit() Callable or Runnable object. You can also created it manually.


9. FutureTask is normally used to wrap Runnable or Callable object and submit them to ExecutorService for asynchronous execution.


That's all on How to use Future and FutureTask in Java. Understanding concept behind Future is very important for writing asynchronous code in Java. In simple words, Future allows any method to return immediately, with promise of result being available in future. By using this technique your main thread can do other things while waiting for certain task to be completed.

6 comments :

SARAL SAXENA said...

Hi Javin,

pls check my blog on this , pls lem me know your feedback on this..

http://saralsaxena.blogspot.in/2015/01/parallel-processing_4.html

Anonymous said...

One of the drawback of using Future is that you either need to periodically check whether task is completed or not e.g. by using isDone() method or wait until task is completed by calling blocking get() method. There is no way to receive the notification when task is completed. This shortcoming is addressed in CompletableFture, which allows you to schedule some execution when the task is done. CompletableFuture class is introduced in Java 8 and you can perform some task when Future reaches completion stage.

Unknown said...

What is purpose of Thread pool here. I can have n number of threads from pool and program output does not vary at all.

Javin Paul said...

In this program, because there is only one call to calculate factorial, thread pool is not really tested. If you want to test thread pool, calculate factorial from multiple threads. Since we are using a fixed thread pool of size 3, you will notice your thread waiting longer as you calculate large factorials.

Dai Kaixian said...

thanks for your article.It helps me.

Unknown said...

How to submit three tasks to threadpool? Creating three instances of FactorialCalculator and then
Future future1 = threadpool.submit(task1);
Future future2 = threadpool.submit(task2);
Future future3 = threadpool.submit(task3);

Post a Comment