Callable and Future

While Runnable represents a void task that cannot return values or throw checked exceptions, Callable<V> returns a generic result and can throw exceptions. A Future<V> acts as a handle to retrieve this asynchronous result.

Callable vs. Runnable

Let's compare the two interfaces:

• Method Signature: Runnable defines void run(); Callable defines V call() throws Exception.
• Exceptions: Callable can throw checked exceptions directly from the signature. Runnable must catch all checked exceptions locally.
• Retrieval: Future.get() blocks the calling thread until the Callable finishes execution.

Code Walkthrough

This program demonstrates how to submit a Callable task to an ExecutorService and resolve the Future result.

import java.util.concurrent.*;
public class CallableDemo {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
Callable task = () -> {
            Thread.sleep(1000); // Simulate heavy math
            return 42;
        };
System.out.println("Submitting task...");
        Future future = executor.submit(task);
try {
            // Future.get() blocks until the value is ready
            Integer result = future.get(2, TimeUnit.SECONDS); 
            System.out.println("Result received: " + result);
        } catch (TimeoutException e) {
            System.err.println("Task timed out!");
        } catch (InterruptedException | ExecutionException e) {
            System.err.println("Execution failed: " + e.getCause());
        } finally {
            executor.shutdown();
        }
    }
}

Interview-Relevant Information