How to wait for all threads to finish, using ExecutorService?

Synchronization techniques and tricks

While the awaitTermination() function serves as an essential instrument in thread synchronization, it's not the only tool in your arsenal. Here's a brief exploration of a few more advanced techniques for practical usage:

Synchronous batch task submission using the invokeAll method

In scenarios where a collection of tasks need to be submitted, and a hold is required until all the tasks complete (like waiting for all your children to finish their homework before bedtime), you can utilize invokeAll(). Here's how:

ExecutorService executor = Executors.newFixedThreadPool(4);
List<Callable<Object>> tasks = new ArrayList<>();
tasks.add(/* Station to Station, add your task here */);
// ...
List<Future<Object>> futures = executor.invokeAll(tasks);


This method blocks until all tasks have completed their execution. Subsequently, you can call for a shutdown.

Comprehensive coordination using CompletableFutures

CompletableFuture, akin to an over-achieving octopus, provides a rich API brimming with capabilities for asynchronous programming. Use it to coordinate tasks effectively:

List<CompletableFuture<Void>> futuresList = tasks.stream()
    .map(task -> CompletableFuture.runAsync(task, executor))
    .collect(Collectors.toList());

CompletableFuture<Void> allOf = CompletableFuture.allOf(futuresList.toArray(new CompletableFuture[0]));
allOf.join(); // All aboard! Wait for all to complete

executor.shutdown(); // Don't forget the cleanup crew


CountDownLatch for Dexterous Thread Control

CountDownLatch is your friend when you need to initiate certain tasks concurrently and wait for all to end before advancing (like a very precise relay race):

CountDownLatch latch = new CountDownLatch(taskCount);
// Submit tasks
for(int i = 0; i < taskCount; i++) {
    executor.submit(() -> {
        try {
            // Dancing shoes, do your task moves here
        } finally {
            latch.countDown();
        }
    });
}

latch.await(); // Waiting lounge, until all tasks call countDown()
executor.shutdown(); 


Envelop the countDown() call in a finally block to ensure it gets called, irrespective of exceptions that might exist within the task.

Note: Depending on your specific use case (and how the wind is blowing), you may find some of these methods to be more suitable than others.

Tiptoeing around potential potholes

Working with threads is as much an adventure as it is a science. Here are some common potholes you might encounter on the route:

Anticipating and Handling InterruptedException

Like a surprise pop quiz, interrupted exceptions can catch you off guard. It's generally a good idea to restore the interrupt state with Thread.currentThread().interrupt(); when an InterruptedException materializes.

Shutdown drills

Much like fire drills, effective shutdown drills are essential to good thread management. Always nest your shutdown commands in a finally block or post all completion checks to ensure execution.

Dealing with Task Exceptions

Tasks dispatched to an ExecutorService may hurl exceptions your way, often wrapped in a surprise ExecutionException. Use Future.get() to detect and respond to these curveballs.

Crowded House

New threads are a resource expense. While the all-you-can-eat newFixedThreadPool buffet can be tempting, ensure you keep the pool size reasonable for a balanced diet.