How to Implement Callable and Future in Java?

Question

What is the actual implementation of Callable and Future in Java?

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;

public class CallableExample {
    public static void main(String[] args) {
        // Create an ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Create a Callable task
        Callable<String> task = () -> {
            Thread.sleep(2000); // Simulate long-running task
            return "Task completed!";
        };

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

        try {
            // Retrieve the result of the Callable
            String result = future.get(); // This will block until the result is available
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

Answer

In Java, Callable and Future facilitate concurrent programming, allowing tasks to run asynchronously and returning results through the Future interface. Callable is a functional interface that can return a value and throw checked exceptions, unlike Runnable.

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;

public class CallableExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Callable<String> task = () -> {
            Thread.sleep(2000);
            return "Task completed!";
        };
        Future<String> future = executor.submit(task);
        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

Causes

Understanding the differences between Callable and Runnable.
Knowing when to use ExecutorService for executing tasks.

Solutions

Use Callable for tasks that return results or throw exceptions.
Retrieve results from a Callable using the Future interface, which allows blocking until the result is available.

Common Mistakes

Mistake: Not handling exceptions in Callable properly.

Solution: Always catch and handle exceptions in the Callable to avoid unexpected behaviors.

Mistake: Ignoring the shutdown of ExecutorService.

Solution: Make sure to call executor.shutdown() after finishing the tasks to release resources.

Helpers

Callable interface
Future interface
Java concurrent programming
ExecutorService
Java Callable example