What are some examples of using Future interface in Java?

What are some examples of using Future interface in Java?

The Future interface in Java represents the result of an asynchronous computation. Here are a few examples:

1. Basic Usage: You can use the ExecutorService to submit a task that returns a Future object. For example:

   ExecutorService executor = Executors.newFixedThreadPool(2);
   Future<Integer> future = executor.submit(() -> {
       // Simulate long-running task
       Thread.sleep(1000);
       return 123;
   });
   

2. Getting Result: You can retrieve the result using future.get(), which blocks until the result is available:

   Integer result = future.get(); // This will wait until the computation is done
   

3. Handling Exceptions: If the computation throws an exception, you can catch it when calling get():

   try {
       Integer result = future.get();
   } catch (ExecutionException e) {
       // Handle exception
   }
   

4. Checking Completion: You can check if the task is completed using future.isDone():

   if (future.isDone()) {
       // Task is completed
   }
   

These examples illustrate how to work with the Future interface in Java.

Can you explain how to handle exceptions with Future?

Certainly! When you call future.get(), it can throw an ExecutionException if the computation threw an exception. Here's how you can handle it:

try {
    Integer result = future.get();
} catch (ExecutionException e) {
    Throwable cause = e.getCause(); // Get the original exception
    System.out.println("Task failed with exception: " + cause.getMessage());
} catch (InterruptedException e) {
    Thread.currentThread().interrupt(); // Restore interrupted status
}

In this code, if the task fails, you can access the original exception using e.getCause().

What is the difference between Future and CompletableFuture?

The main differences are:

1. CompletableFuture is a subclass of Future that allows you to write non-blocking asynchronous code. You can chain multiple actions using methods like thenApply, thenAccept, etc.

2. Future is more basic and only allows you to retrieve the result or check if the task is done. It does not support chaining or combining multiple futures easily.

3. CompletableFuture can be manually completed using complete() or completeExceptionally(), while a regular Future is completed by the executor.