Callable and Future in Java

In Java, Callable and Future are the two most important concepts that are used with thread. In this section, we will understand how we can use Callable and Future in our code.

Future is used for storing a result received from a different thread, whereas Callable is the same as Runnable in that it encapsulates a task that is meant to be run on another thread.

Let's understand each one of them one by one with an example:

Callable Interface

Java offers two ways for creating a thread, i.e., by extending the Thread class and by creating a thread with a Runnable. There is a drawback of creating a thread with the Runnable interface, i.e., we cannot make a thread return result when it terminates, i.e., when the run() completes. In order to overcome this drawback, Java provides the Callable interface.

These are the two main differences between the Callable and Runnable methods:

The run() method is used for implementing the Runnable, whereas the call() method is used for implementing the Callable. The run() method doesn't return anything, whereas the call() method returns a result of completion.
The call() method can throw an exception, whereas the run() method cannot.

Note: We can create a thread by using Runnable, not by using Callable.

The syntax of the call() method is as follows:

public Object call() throws Exception;

Let's take an example to understand how we can use Callable interface:

CallableInterfaceExample.java

// import required classes and package if any 
import java.util.concurrent.Callable;   
import java.util.Random;   
 
//create class CallableInterfaceExample that implements Callable interface 
class CallableInterfaceExample implements Callable<Object> {   
    
    // override the call() method 	 
    @Override   
    
    public Object call() throws Exception {   
        
        //create an instance of the  Random class    
        Random obj = new Random();   
        
        //generate a random number between 0-100 
        Integer number = obj.nextInt(100);   
        
        //delay thread for some random time   
        Thread.sleep(number * 1000);   
        
        //return the object having the generated random number   
        return number;   
    }    
}  

Future

In the main() method, the returned value of the call() method(after completion) should be stored in an object to know about the result that the thread returns. In order to store the returned data in the main() method, we use a Future object.

The future is one of the ways through which we can keep track of the progress and result from other threads. We need to override the five methods for implementing the Future interface. The cancel(), get() and isDone() methods are the most important methods from the Future interface.

public boolean cancel(boolean mayInterrupt)

The cancel() method is used to stop the task if it has not started. If the task has started and the mayInterrupt boolean value is true, it will interrupt that task too.

public Object get() throws InterruptedException

The method returns the result of the task. It returns the result immediately if the task is completed; else, it will wait for its completion and then returns the result.

public boolean isDone() throws InterruptedException

It returns a boolean value based on the completion of the task.

Note: For creating a thread, a Runnable is necessary.

Note: For obtaining the result, a Future is necessary.

Let's take an example to understand how we can use Future to store the returned result of call() in the main() method:

CallableFutureExample.java

//import required classes and package if any 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.FutureTask; 
import java.util.Random;   
 
//create class CallableInterface that implements Callable interface 
class CallableInterface implements Callable<Object> {   
    
    // override the call() method 	 
    @Override   
    
    public Object call() throws Exception {   
        
        //create an instance of the  Random class    
        Random obj = new Random();   
        
        //generate a random number between 0-10 
        Integer number = obj.nextInt(10);   
        
        //delay thread for some random time   
        Thread.sleep(number * 1000);   
        
        //return the object having the generated random number   
        return number;   
    }   
}   
 
// create CallableFutureExample class 
public class CallableFutureExample{ 
    
    //main() method start 
    @SuppressWarnings({ "unchecked", "rawtypes" }) 
    
    public static void main(String args[]) throws InterruptedException, ExecutionException { 
        
        //create an array of FutureTask 
        //A concrete class having implementation of both Runnable and Future is called FutureTask 
        FutureTask[] returnedTask = new FutureTask[5]; 
        
        //use for loop 
        for(int i = 0; i < 5; i++) { 
            //create an instance of Callable 
            Callable callableObj = new CallableInterface(); 
            
            //create an instance of FutureTask with Callable 
            returnedTask[i] = new FutureTask(callableObj); 
            
            // create a Thread with FutureTask 
            Thread thread = new Thread(returnedTask[i]); 
            
            thread.start(); 
        } 
        
        //use for loop for printing returned value of each callable 
        for(int j = 0; j < 5; j++) { 
            // use get() method of FutureTask to print the returned value 
            System.out.println("Callable["+j+"] ===> "+returnedTask[j].get()); 
        } 
    } 
}

Output:

Let's take another example in which we will use only the Runnable interface.

RunnableExample.java

//import required classes and package if any 
import java.util.Random;   
 
//create class RunnableInterface that implements Runnable interface 
class RunnableInterface implements Runnable { 
    
    // create a shared Object for storing result 
    private Object result = null; 
    
    @Override 
    public void run() { 
        
        //create an instance of Random class for generating random number 
        Random obj = new Random(); 
        
        // generate random number using Random class 
        Integer number = obj.nextInt(10); 
        
        // use try-catch because Runnable doesn't throw any Exception 
        try { 
            Thread.sleep(number * 10); 
        }catch(InterruptedException exception) { 
            exception.printStackTrace(); 
        } 
        
        // store the returned value in result after completion 
        result = number; 
        
        // wake up threads blocked on the get() method  
        synchronized(this) { 
            notifyAll(); 
        } 
    } 
    
    // get() method for returning the result 
    public synchronized Object get() throws InterruptedException{ 
        
        while(result == null) { 
            wait(); 
        } 
        return result; 
    } 
}   
 
//create RunnableExample class 
public class RunnableExample { 
    
    //main() method start 
    public static void main(String args[]) throws InterruptedException { 
        
        //create an array of RunnableInterface 
        RunnableInterface[] tasks = new RunnableInterface[5]; 
        
        //use for loop 
        for(int i = 0; i < 5; i++) { 
            //create an instance of RunnableInterface 
            tasks[i] = new RunnableInterface(); 
            
            // create a Thread with RunnableInterface 
            Thread thread = new Thread(tasks[i]); 
            
            thread.start(); 
        } 
        
        //use for loop for printing returned value of each Runnable 
        for(int j = 0; j < 5; j++) { 
            // use get() method to print the returned value 
            System.out.println("Runnable["+j+"] ===> "+tasks[j].get()); 
        } 
    } 
}

Output: