Callable & Future

Callable and Future are important parts of Java’s Concurrency API. They help you run tasks in the background and get results safely once the task is completed.

If you want to execute a task asynchronously and receive a result later, then Callable and Future are the best tools in Java.

What is Callable in Java?

Callable is a functional interface that represents a task that can be executed asynchronously and returns a result.

It is similar to Runnable, but with two important differences:

1. Returns a result – Unlike Runnable, which cannot return any value, Callable returns a value of type V.
2. Throws exceptions – Callable can throw checked exceptions, whereas Runnable cannot.

Key Points:

• Found in the package: java.util.concurrent
• Works with ExecutorService to run tasks asynchronously
• Returns a result through a Future object

Syntax:

@FunctionalInterface
publicinterfaceCallable<V> {
    Vcall()throws Exception;
}

In simple words:

Callable = Runnable + Returns a Result + Can Throw Exceptions

Example: Using Callable

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

publicclassCallableExample {
publicstaticvoidmain(String[] args)throws Exception {
// Create a thread pool
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

// Create a Callable task
        Callable<Integer> task = () -> {
intsum=0;
for (inti=1; i <=5; i++) {
                sum += i;
            }
return sum;// return result
        };

// Submit task to executor
        Future<Integer> futureResult = executor.submit(task);

// Get result from Future
Integerresult= futureResult.get();// waits until task completes
        System.out.println("Sum: " + result);

// Shutdown executor
        executor.shutdown();
    }
}

Sample Output:

Sum: 15

—> Notice how the task returns a result through the Future object, unlike Runnable which doesn’t return anything.

Advantages of Callable

1. Can Return a Result

• Unlike Runnable, Callable tasks return a value.
• Useful for calculations, database operations, or API calls where you need a result.

2. Can Throw Checked Exceptions

• Callable can throw exceptions, which allows better error handling in multithreaded tasks.

3. Works with ExecutorService

• Callable works seamlessly with ExecutorService, allowing asynchronous task execution without manual thread management.

4. Supports Future for Results

• When submitted to an ExecutorService, Callable returns a Future object, which can be used to get results, check task status, or cancel tasks.

5. Ideal for Long-Running Tasks

• Perfect for tasks that require computation and return values, especially when multiple tasks run concurrently.

When to Use Callable in Java

You should use Callable instead of Runnable in situations where:

• Returns a result – For example, a sum, database query, or API response.
• Handles exceptions – Callable can throw checked exceptions for better error handling.
• Runs asynchronously – Works with ExecutorService and returns a Future for background execution.
• Performs long-running or concurrent tasks – Ideal for parallel computations, batch jobs, or multiple API calls that produce results.

Difference Between Runnable and Callable in Java

Runnable and Callable are interfaces used in Java to define tasks that run in separate threads. While both are part of Java’s concurrency mechanism, they are used in different situations.

What is Future in Java?

Future represents the result of an asynchronous computation.

It allows you to:

• Get the result of a task that may not have finished yet
• Check if the task is completed
• Cancel a task if needed

Key Points:

• Package: java.util.concurrent
• Works with Callable or Runnable tasks
• Helps handle tasks safely in multithreaded programs

Common Methods:

Example: Using Future

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

publicclassFutureExample {
publicstaticvoidmain(String[] args)throws Exception {
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

        Callable<String> task = () -> {
            Thread.sleep(500);// simulate work
return"Task Completed!";
        };

// Submit task and get a Future
        Future<String> future = executor.submit(task);

        System.out.println("Task submitted, waiting for result...");

// Check if task is done
if(!future.isDone()){
            System.out.println("Task is still running...");
        }

// Get the result
Stringresult= future.get();
        System.out.println("Result: " + result);

        executor.shutdown();
    }
}

Sample Output:

Task submitted, waitingfor result...
Task is still running...
Result:Task Completed!

Explanation:

• Future.get() waits for the task to complete and returns the result.
• isDone() allows you to check the task status before retrieving the result.
• ExecutorService handles the threads, making asynchronous execution safe and efficient.

Why Use Callable & Future Together?

• Safe result retrieval from background threads
• Clean exception handling
• No manual thread management
• Scalable and responsive applications

Best Practices

• Always call shutdown() on ExecutorService
• Use Callable when results are required
• Use Future to monitor or cancel tasks
• Choose thread pool size wisely
• Avoid creating too many threads

Difference Between Callable and Future

Conclusion

• Callable defines a task that returns a result
• Future manages and retrieves that result
• Together, they enable safe, efficient, and asynchronous programming

If you are learning ExecutorService, then Callable & Future are must-know concepts for modern Java development.