Home  >  Core Java

Java Callable Example

By Arvind Rai, June 07, 2022
On this page we will learn using Java Callable in our application.
1. The Callable is a task that returns a result and may throw an exception.
2. The Callable is a functional interface whose functional method is call(). Find the method declaration.
V call() throws Exception 
It returns computed result.
It throws Exception if unable to compute a result.
3. The Callable is similar to Runnable. But Runnable does not return a result and cannot throw a checked exception.
4. The Callable can be instantiated with lambda expression, method reference, Executors.callable and class.



Create Callable

The Callable has functional interface call() that returns value and does not accept argument. We can create Callable instance in following ways.
1. Using Lambda Expression
Callable<String> task = () -> {
	System.out.println("Executing Task-1");
	return "Success";
}; 
2. Using Method Reference
Suppose we have a class.
class Task {
  public static int count() {
	int i = 1;
	for(; i < 5; i++) {
	  System.out.println(i);
	}
	return i;
  }
} 
The method declaration of count() is matching to functional method call() of Callable.
We can instantiate Callable using method reference as following.
Callable<Integer> myTask = Task::count; 
3. Using Callable Interface
Create a class implementing Callable interface.
class Task implements Callable<Integer> {
  @Override
  public Integer call() throws Exception {
	int i = 1;
	for(; i < 5; i++) {
	  System.out.println(i);
	}
	return i;
  }
} 
Now create instance of Task class.
Callable<Integer> myTask = new Task(); 
4. Using Executors.callable
We can create Callable instance using Executors.callable method that has following declarations.
a.
static Callable<Object> callable(Runnable task) 
Creates Callable that returns null.
b.
static <T> Callable<T> callable(Runnable task, T result) 
Creates Callable that returns specified result.
c.
static Callable<Object> callable(PrivilegedAction<?> action) 
Creates Callable that returns the result of given privileged action.
d.
static Callable<Object> callable(PrivilegedExceptionAction<?> action) 
Creates Callable that returns the result of given privileged exception action.

Example
Runnable runnable = () -> {
	for(int i = 1 ; i < 5; i++) {
	  System.out.println(i);
	}
};
Callable<String> myTask = Executors.callable(runnable, "Done"); 

Run Callable

1. The instance of Callable can be executed using Java concurrent Future.
2. The Future represents the result of an asynchronous computation. It provides methods to check if the computation is complete, to wait for its completion, and to retrieve the result of the computation.
3. Thread pool is created using Executors method such as newCachedThreadPool, newFixedThreadPool, newScheduledThreadPool etc.

Example-1
CallableDemo1.java
package com.concretepage;
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.concurrent.TimeUnit;
public class CallableDemo1 {
  public static void main(final String... args) throws InterruptedException, ExecutionException {
	Callable<String> task1 = () -> {
	    System.out.println("Executing Task-1");
	    return "Task-1 Finish.";
	};
	Callable<String> task2 = () -> {
	    System.out.println("Executing Task-2");
	    return "Task-2 Finish.";
	};

	ExecutorService executorService = Executors.newFixedThreadPool(1);
	Future<String> future1 = executorService.submit(task1);
	Future<String> future2 = executorService.submit(task2);

	String output1 = future1.get();
	System.out.println(output1);

	String output2 = future2.get();
	System.out.println(output2);

	executorService.awaitTermination(3, TimeUnit.SECONDS);
	executorService.shutdownNow();
  }
} 
Output
Executing Task-1
Executing Task-2
Task-1 Finish.
Task-2 Finish. 
Example-2
CallableDemo2.java
package com.concretepage;
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.concurrent.TimeUnit;
public class CallableDemo2 {
  public static void main(final String... args) throws InterruptedException, ExecutionException {
	Runnable runnable = () -> {
		for(int i = 1 ; i < 5; i++) {
		  System.out.println(i);
		}
	};
	Callable<String> myTask = Executors.callable(runnable, "Done");

	ExecutorService executorService = Executors.newCachedThreadPool();
	Future<String> future = executorService.submit(myTask);
	
	String output = future.get();
	System.out.println(output);

	executorService.awaitTermination(2, TimeUnit.SECONDS);
	executorService.shutdownNow();
	
  }
} 
Output
1
2
3
4
Done 
Example-3
CallableDemo3.java
package com.concretepage;
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.concurrent.TimeUnit;
public class CallableDemo3 {
  public static void main(final String... args) throws InterruptedException, ExecutionException {
	Callable<String> myTask = new Task();

	ExecutorService executorService = Executors.newSingleThreadExecutor();
	Future<String> future = executorService.submit(myTask);

	String output = future.get();
	System.out.println(output);

	executorService.awaitTermination(3, TimeUnit.SECONDS);
	executorService.shutdownNow();
  }
} 
class Task implements Callable<String> {
  @Override
  public String call() throws Exception {
    System.out.println("Fetching data ...");
	return "success";
  }
} 
Output
Fetching data ...
success 

Reference

Interface Callable
POSTED BY
ARVIND RAI
ARVIND RAI










©2022 concretepage.com | Privacy Policy | Contact Us