Course contentsShow
← Java
Lesson 2617 of 2,87048. Concurrency FundamentalsFree lesson

join vs Other Synchronization: When to Use Each

Compare join with ExecutorService.shutdown, CountDownLatch, and other coordination mechanisms.

join vs Other Synchronization: When to Use Each

You'll learn when join is the right choice and when other coordination mechanisms serve better.

When to Use join

Use join when you need to wait for specific threads to finish before proceeding. It's perfect for scatter-gather patterns where you know exactly which threads you're waiting for:

Thread t1 = new Thread(() -> processFile("file1.txt"));
Thread t2 = new Thread(() -> processFile("file2.txt"));
t1.start();
t2.start();
t1.join();  // Wait for t1
t2.join();  // Wait for t2
// Now both are done

Limitation: join requires direct thread references. You can't easily coordinate threads you didn't create yourself.

When to Use ExecutorService.shutdown/awaitTermination

When working with thread pools, you rarely have direct thread references. Use shutdown() and awaitTermination() instead:

// Assuming ExecutorService exists from earlier lessons
// executor.shutdown();
// executor.awaitTermination(1, TimeUnit.MINUTES);

This waits for all submitted tasks to complete without needing individual thread references.

When to Use CountDownLatch

Use CountDownLatch when multiple threads must wait for N events to occur, regardless of which specific threads trigger them:

// Assuming CountDownLatch exists from earlier context
// CountDownLatch latch = new CountDownLatch(3);
// latch.countDown(); // called by workers
// latch.await();     // waits for count to reach zero

Unlike join, the waiting thread doesn't care which threads counted down, just that the count reached zero.

The Right Tool for the Job

  • join: You created specific threads and need to wait for those exact threads
  • ExecutorService: You're managing a pool and care about task completion, not specific threads
  • CountDownLatch: You're coordinating based on event counts, not thread identity

Key Takeaway: Use join for simple thread-to-thread coordination; reach for higher-level abstractions like ExecutorService or CountDownLatch when you need more flexible coordination patterns.