Java ExecutorService example using Callable and Future

Callable interface represents a thread that can return a value. It is very much similar to Runnable interface except that it can return a value. Callable interface can be used to compute status or results that can be returned to invoking thread. For example: Let’s say you want to perform factorial and square of some numbers, you can do it concurrently using callable interface which will return value too. Callable defines only one method as below

public interface Callable {

V call() throws Exception;

}

You can define the task which you want to perform inside call method. If it executes successfully, call method will return the result else it must throw an exception. You can use ExecutorService’s submit to execute Callable task. Let’s see Signature of submit method in ExecutorService.

Future submit(Callable task);

If you notice, return type of submit method is Future.

Future is generic interface that represents value which will be returned by callable interface. As callable will return value in some future time, name seems suitable here.

There are two methods to get actual value from Future.

get() : When this method is called, thread will wait for result indefinitely.

V get(long timeout, TimeUnit unit) : When this method is called, thread will wait for result only for specified time.

Example:

This program will demonstrate use of Callable and Future. We will create one callable for calculation of square and one callable for factorial. We will submit four tasks to ExecutorService for calculation of square and factorial of 20 and 25. This program will demonstrate how can you make use of Callable and Future to execute it concurrently.

Create class called PowerCalc which implements Callable interface.

package org.arpit.java2blog;

import java.util.concurrent.Callable;

public class PowerCalc implements Callable{

private double number;

PowerCalc(double number)

public Double call() throws Exception {

{

this.number=number;

}

@Override

System.out.println("Calculating Square with "+Thread.currentThread().getName());

Thread.sleep(2000);

return Math.pow(number, number);

}

Create another class called FactorialCalc which implements Callable interface.

package org.arpit.java2blog;

import java.util.concurrent.Callable;

public class FactorialCalc implements Callable {

private double number;

FactorialCalc(double number) {

public Double call() throws Exception {

this.number = number;

}

@Override

System.out.println("Calculating factorial with "+Thread.currentThread().getName());

Thread.sleep(5000);

double fact = 1;

for (int i = 2; i <= number; i++) {

fact *= i;

}

return fact;

}

Now create a main classed named FutureCallableMain.java.

package org.arpit.java2blog;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Future;

import java.util.concurrent.Executors;

public class FutureCallableMain {

ExecutorService es=Executors.newFixedThreadPool(4);

public static void main(String[] args) {

System.out.println("Start : ");

Future powerFuture20;

powerFuture20=es.submit(new PowerCalc(20));

Future factorialFuture20;

Future powerFuture25;

Future factorialFuture25;

factorialFuture25=es.submit(new FactorialCalc(25));

factorialFuture20=es.submit(new FactorialCalc(20));

powerFuture25=es.submit(new PowerCalc(25));

try {

System.out.println("Square of "+25+" : "+powerFuture25.get());

System.out.println("Square of "+20+" : "+powerFuture20.get());

System.out.println("Factorial of "+20+" : "+factorialFuture20.get());

es.shutdown();

System.out.println("Factorial of "+25+" : "+factorialFuture25.get());

} catch (InterruptedException | ExecutionException e) {

e.printStackTrace();

}

System.out.println("Done");

}

When you run above program, you will get below output:

Start :

Calculating Square with pool-1-thread-1

Calculating factorial with pool-1-thread-2

Calculating Square with pool-1-thread-3

Square of 20 : 1.048576E26

Calculating factorial with pool-1-thread-4

Factorial of 20 : 2.43290200817664E18

Done

Square of 25 : 8.881784197001253E34

Factorial of 25 : 1.5511210043330986E25

As you can see, we are able to execute 4 tasks concurrently which return square and Factorial of 20 and 25.

Get Thread Id in Java

ArrayBlockingQueue in java

Delay Java program for few secs

How to print even and odd numbers using threads in java

Why wait(), notify() And notifyAll() methods are in Object Class

Custom BlockingQueue implementation in java

Difference between Runnable and Callable in java

Print sequence using 3 threads in java

Java Runnable example

Java Executor framework tutorial with example

Author

Difference between Runnable and Callable in java

Concurrent APIs Multithreading Core Java interview Interview

16 December

Difference between Runnable and Callable in java

Runnable and Callable interface both are used in the multithreading environment.Callable is available in java.util.concurrent.Callable package and Runnable in java.lang.Thread. Difference between Runnable and Callable interface in java Runnable was introduced in java 1.0 version While Callable is an extended version of Runnable and introduced in java 1.5 to address the limitation of Runnable. Runnable […]

Concurrent APIs Core Java interview Multithreading

13 June

Java Executor framework tutorial with example

Table of ContentsExecutorExecutorServiceScheduledExecutorServiceExecutorsThreadPoolExecutor Java 5 has introduced new framework called Executor Framework for managing threads.We have already seen before how to create a thread. If you have noted, we need to create an object of thread class using new Thread(runnableObject), so we need to create thread object for each task.Imagine a situation where you have […]

Concurrent APIs Multithreading Core Java interview Interview

09 June

Java ExecutorCompletionService

Table of ContentsWhy you may need to use ExecutorCompletionService:Java ExecutorCompletionService example: In this post, we will see about Java ExecutorCompletionService example. ExecutorCompletionService class implements CompletionService. This class returns Future object in completion order. Why you may need to use ExecutorCompletionService: Let’s understand with the help of scenario: Let’s say you have 5 tasks, you submit it to the […]

Concurrent APIs Core Java interview Multithreading

05 June

Java newSingleThreadExecutor example

Table of ContentsSyntax:Java newSingleThreadExecutor example:Difference between newSingleThreadExecutor and newFixedThreadPool(1): In this tutorial, we will learn about Executor’s newSingleThreadExecutor factory method. In the last tutorial, I have shared an introduction to ThreadPoolExecutor. If you are not aware of concepts of ThreadPoolExecutor, you should go through that first. Executor’s newSingleThreadExecutor factory method : This method returns thread […]

Concurrent APIs Core Java interview Multithreading

29 May

Java ScheduledThreadPoolExecutor Example

Table of ContentsJava ScheduledThreadPoolExecutor Example:ScheduledThreadPoolExecutor’s scheduleAtFixedRate example:ScheduledThreadPoolExecutor’s scheduleWithFixedDelay example: There are multiple ways to schedule a task in java. We have already Java timer to schedule a task but the problem with timers task is that you can execute one task at a time.So if the current task takes longer subsequent job will be delayed. […]

Concurrent APIs Multithreading Core Java interview Interview

28 May

Java FutureTask example

Table of ContentsJava FutureTask example:Explanation: In this tutorial, we will see about Java FutureTask example. FutureTask class has been introduced in JDK 5 with Executor Framework. FutureTask class is the concrete implementation of the Future object and provides methods for start and cancel the task.It also provides method to see if the computation is done […]