What are alternatives to Runnable and how do they compare?

In Java, while the Runnable interface is commonly used for creating threads, there are several alternatives worth considering:

• Callable: Unlike Runnable, Callable can return a result and can throw checked exceptions.
• ExecutorService: A higher-level replacement for managing threads that simplifies thread management through a thread pool.
• ForkJoinPool: Designed for parallelism, particularly useful for CPU-bound tasks that can be split into smaller subtasks.
• CompletableFuture: Allows writing asynchronous non-blocking code with methods to handle the outcome without dealing with the thread explicitly.

Each alternative has its own use cases, with Callable and CompletableFuture providing more flexibility with results and exception handling. On the other hand, ExecutorService provides a higher level of control over thread management.

        // Example of using Callable
        import java.util.concurrent.Callable;
        import java.util.concurrent.ExecutionException;
        import java.util.concurrent.ExecutorService;
        import java.util.concurrent.Executors;

        public class Main {
            public static void main(String[] args) {
                ExecutorService executor = Executors.newFixedThreadPool(2);
                
                Callable task = () -> {
                    Thread.sleep(1000);
                    return "Task completed";
                };

                try {
                    String result = executor.submit(task).get();
                    System.out.println(result);
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                } finally {
                    executor.shutdown();
                }
            }
        }