Java Callable Example

Java provides two approaches for creating threads one by implementing the Runnable interface and the other by inheriting the Thread class. However, one important feature missing with the implementation of the Runnable interface is that it is not possible for a thread to return something when it completes its execution, i.e., when the run() method execution is over. In order to support this feature, the Java Callable interface is used.

To understand the concept of callable, one must friendly with threads and multithreading concepts.

The call() Method Signature

Callable Examples

Let's observe the code snippet which implements the Callable interface and returns a random number ranging from 0 to 9 after making a delay between 0 to 4 seconds.

FileName: JavaCallableExample.java

// A Java program that illustrates Callable
// to generate and return a random number between 0 - 9

// import statments
import java.util.concurrent.Callable;
import java.util.Random;

class JavaCallable implements Callable
{

public Object call() throws Exception
{
// Creating an object of the  Random class 
Random randObj = new Random();

// generating a random number between 0 to 9
Integer randNo = randObj.nextInt(10);

// the thread is delayed for some random time
Thread.sleep(randNo * 1000);

return randNo;
}
}

Explanation: The above code snippet shows how one can implement the callable interface. However, the job is not done. When the call() method terminates, the returned object must be stored that is known to the main thread. It is important because the main thread must know the result generated in the call() method. To accomplish the same, a Future object is used. A Future object holds the result obtained from the different thread, which is sent from the call() method.

Just like Callable, Future is also an interface. Therefore, to use it, its implementation is a must. However, we do not have to take the pain to implement the Future interface. The Java library already has the class called, FutureTask that implements the Runnable as well as the Future interfaces.

Now, let's extend the above code snippet.

FileName: JavaCallableExample.java

// A Java program that illustrates Callable
// to generate and return a random number between 0 - 9

// import statments
import java.util.concurrent.Callable;
import java.util.Random;

// importing the concrete class FutureTask
import java.util.concurrent.FutureTask;

class JavaCallable implements Callable
{
@Override
public Object call() throws Exception
{
// Creating an object of the  Random class 
Random randObj = new Random();

// generating a random number between 0 to 9
Integer randNo = randObj.nextInt(10);

// the thread is delayed for some random time
Thread.sleep(randNo * 1000);

// return the object that contains the 
// generated random number
return randNo;
}
}

public class JavaCallableExample
{
  // main method
  public static void main(String argvs[]) throws Exception
  {
  
    // FutureTask is the concrete class
    // creating an array of 5 objects of the FutureTask class
    FutureTask[] randomNoTasks = new FutureTask[10];
  
    // loop for spawning 10 threads
    for (int j = 0; j < 10; j++)
    {
      // Creating a new object of the JavaCallable class
      Callable clble = new JavaCallable();
  
      // Creating the FutureTask with Callable
      randomNoTasks[j] = new FutureTask(clble);
  
      // Since FutureTask implements Runnable, 
      // one can create a Thread
      // with a FutureTask object
      Thread th = new Thread(randomNoTasks[j]);
      th.start();
    }
  
    // loop for receiving the random numbers
    for (int j = 0; j < 10; j++)
    {

      // invoking the get() method
      Object o = randomNoTasks[j].get();
      
      // The get method holds the control until the result is received
      // The get method may throw the checked exceptions
      // like when the method is interrupted. Because of this reason
      // we have to add the throws clause to the main method
      
       // printing the generated random number
      System.out.println("The random number is: " + o);

    }
  }
}

Output:

The random number is: 5
The random number is: 0
The random number is: 1
The random number is: 3
The random number is: 9
The random number is: 0
The random number is: 7
The random number is: 9
The random number is: 3
The random number is: 5

Explanation: In the code, we have produced 10 different threads. Each thread invokes the call() method, generates a random number, and returns it. The get() method is used to receive the returned random number object obtained from the different threads to the main thread. The get() method is declared in the Future interface and implemented in the FutureTask class.

Differences between Callable and Runnable Interface

The following table shows the differences between the Callable and Runnable interfaces.

Callable	Runnable
It is mandatory to define call() method if we are dealing with the Callable interface.	It is mandatory to define the run() method if we are dealing with the Runnable interface.
The return type of the call() method of the interface is an Object. Hence, the call() method returns an Object.	The return type of the run() method of the interface is void. Hence, the run() method returns void.
The call() method can throw an exception.	The run() method cannot throw an exception.
A thread cannot be created using the Callable interface.	A thread can be created using the Runnable interface.