What are the Differences Between Runnable and Callable Interfaces in Java?

What is the difference between using the Runnable and Callable interfaces when designing concurrent threads in Java, and why would you choose one over the other?

// Example of Runnable interface
Runnable runnableTask = new Runnable() {
    @Override
    public void run() {
        System.out.println("Task executed using Runnable");
    }
};

// Example of Callable interface
Callable<String> callableTask = new Callable<String>() {
    @Override
    public String call() {
        return "Task executed using Callable";
    }
};

In Java, both the Runnable and Callable interfaces are used to create tasks that can be run in concurrent threads. However, they differ significantly in their functionality and usage scenarios, particularly in how they handle return values and exceptions.

// Using ExecutorService to execute Runnable and Callable
ExecutorService executorService = Executors.newFixedThreadPool(2);

// Submitting Runnable task
executorService.submit(runnableTask);

// Submitting Callable task
Future<String> future = executorService.submit(callableTask);
try {
    String result = future.get(); // Getting result from Callable
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

Causes

• `Runnable` does not return a result or throw a checked exception, focusing solely on executing code in a thread.
• `Callable`, on the other hand, can return a result and allows the throwing of checked exceptions, making it more versatile in certain contexts.

Solutions

• Use `Runnable` when you do not need a result from the execution, which makes it simpler and lighter.
• Use `Callable` when you need to return a result and handle exceptions, which is important for more complex tasks.

Mistake: Using `Runnable` when you need a return value from the task.

Solution: Switch to using `Callable` for tasks requiring a result.

Mistake: Forgetting to handle exceptions in `Callable` tasks, leading to uncaught exceptions.

Solution: Wrap your `Callable` code with appropriate try-catch blocks to handle exceptions properly.