Overview of the Future class works

[pwgit-create]

Key Concepts

1. Asynchronous Execution: The main idea is to execute tasks asynchronously so that the main thread isn't
   blocked waiting for the task to complete.
2. Future Interface: Represents a pending result of an asynchronous computation.

Important Methods

• get(): Blocks until the computation is done and then returns the result.

  • Throws InterruptedException if the current thread is interrupted while waiting.
  • Throws ExecutionException if the computation threw an exception.
  • Throws CancellationException if the computation was cancelled.

• isDone(): Returns true if the computation has completed, either normally or by throwing an exception.

• cancel(boolean mayInterruptIfRunning): Attempts to cancel the execution of this task. If
  mayInterruptIfRunning is true and the thread running the task is interruptible, it will be interrupted.

Example Usage

Let's look at a simple example that demonstrates how to use the Future:

import java.util.concurrent.*;

public class FutureExample {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // Create an ExecutorService with a fixed thread pool of size 2
        ExecutorService executor = Executors.newFixedThreadPool(2);

        // Submit a task for execution and get a Future object representing the pending result
        Callable<String> task = () -> {
            Thread.sleep(5000); // Simulate a long-running task with sleep
            return "Task's execution";
        };

        Future<String> future = executor.submit(task);

        System.out.println("Doing something else while waiting for the task to complete...");

        // Block until the task is done and get the result
        String result = future.get(); // This will block if the task isn't completed yet

        System.out.println(result); // Output: Task's execution

        executor.shutdown();
    }
}

Key Points:

1. ExecutorService: A thread pool that manages a pool of threads and executes tasks asynchronously.
2. Callable: Similar to Runnable, but it returns a result (unlike Runnable which does not return
   anything).
3. Future Object: Represents the pending result of an asynchronous task.

Real-World Usage:

• Asynchronous processing: When you need to perform time-consuming tasks without blocking the main thread.
• Task cancellation: You can cancel a running task if it's no longer needed using future.cancel(boolean mayInterruptIfRunning).
• Checking completion status: Useful for determining whether an asynchronous task has completed using isDone().