Callable interface in Java

The Callable interface is a part of the java.util.concurrent package, introduced in Java 5. It represents a task that can be executed by multiple threads and return a result. Unlike the Runnable interface, Callable can return a value and throw checked exceptions.

• Used with ExecutorService for asynchronous or concurrent execution.
• The result of a Callable is obtained using a Future object.
• It’s a functional interface, so you can use lambda expressions.

Syntax

public interface Callable<V> {
V call() throws Exception;
}

Here:

• V -> The type of result returned by the call() method.
• call() -> The method that performs the computation and returns a result. It can throw a checked exception.

Output:

Explanation:

• A single-threaded ExecutorService is created to run a task.
• The Callable task prints "Calculating...", waits 1 second, and returns 20.
• The task is submitted using executor.submit(task), which returns a Future object.
• future.get() waits for the task to finish and retrieves the result (20).
• Finally, the executor is shut down to release resources.

Methods of Callable Interface

Although Callable has only one abstract method (call()), it works closely with the Future and ExecutorService interfaces.

• V call(): It performs the task and returns a result of type V.
• Future<V>: The Future object allows checking if the task is complete, getting the result, or canceling it.
• ExecutorService.submit(Callable<V>): Submits a Callable task for execution and returns a Future representing the pending result.

Example: Multiple Callable Tasks

Task 1 completed
Task 2 completed
Task 3 completed

Explanation: All tasks are submitted together using invokeAll(). The method waits for all tasks to finish and then returns their results in the same order.

Runnable vs Callable