How to Use Java Executors for Non-Blocking Task Completion Notifications?

What is the best way to receive non-blocking notifications when a task submitted to a Java executor service completes?

ExecutorService executorService = Executors.newSingleThreadExecutor();

Runnable task = () -> {
    // Task execution logic here
};

Future<?> future = executorService.submit(task);

future.whenComplete((result, error) -> {
    if (error != null) {
        // Handle the error
    } else {
        // Proceed with the next task
    }
});

When working with Java's ExecutorService, you might want to submit tasks without blocking the thread while waiting for their completion. Instead of waiting for the result using `Future.get()`, you can leverage the CompletableFuture class to register a callback that will execute once the task is finished. This pattern allows the processing of multiple tasks concurrently without running into stack space issues associated with blocking threads.

import java.util.concurrent.*;

class NonBlockingExecutor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Runnable task1 = () -> System.out.println("Task 1 completed");
        Runnable task2 = () -> System.out.println("Task 2 completed");

        CompletableFuture<Void> future1 = CompletableFuture.runAsync(task1, executorService);
        future1.thenRun(() -> {
            System.out.println("Proceeding to next task...");
            CompletableFuture.runAsync(task2, executorService);
        });
    }
}

Causes

• Task processing might require many threads if each task blocks until completion.
• Stack space may be exhausted due to multiple tasks waiting on blocking threads.
• Submitting many tasks one after another while blocking leads to performance degradation.

Solutions

• Utilize `CompletableFuture` from `java.util.concurrent` to manage task completion without blocking.
• Register callbacks using the `thenRun()` or `thenAccept()` methods of `CompletableFuture` after submitting each task.
• Consider using an `ExecutorCompletionService` to manage task submissions and completions more effectively.

Mistake: Using `Future.get()` which blocks the thread until the task is done.

Solution: Switch to using `CompletableFuture` and its callback mechanisms to avoid blocking.

Mistake: Forgetting to handle exceptions in the task execution.

Solution: Use `handle()` or `exceptionally()` methods to manage exceptions without breaking execution.