What does this thread join code mean?

java

thread-safety

interruptedexception

synchronization

byNikita Barsukov·Nov 22, 2024

The join() call in Java multi-threading essentially tells the current thread to take a break and wait until the invoked thread finished its execution, thereby ensuring that the current thread only proceeds once the desired job on another thread is completed.

Thread t1 = new Thread(() -> {/* I'm busy, leave me alone! */});
t1.start();
t1.join();  // Nap time until t1 is done
// The fun part happens here, but only after t1 is done partying!

In simpler terms, t1.join() helps to organize a sort of relay race between the threads: no runner (thread) starts running until the previous one is finished!

Breaking down join()

The join() method does something like shouting to the main thread, "Hey, I've got some work to finish here! Wait for me!" So if you've got a bunch of threads, say t1 and t2, you can invoke join on both, and the main thread will wait for them to complete their work. But the tasks in t1 and t2 will continue running at the same time like those two friends who always have something to debate about!

Thread t1 = new Thread(() -> {/* Do my thing */});
Thread t2 = new Thread(() -> {/* Do my other thing */});
t1.start();
t2.start();

t1.join(); // I won't move until t1 is done
t2.join(); // Not until t2 is done either!

// Party always starts when everyone's here!

Of course, life isn't always smooth, and the join() method might throw an InterruptedException, indicating that the main thread was given a surprise wake-up call while it was waiting.

try {
    t1.join();
    t2.join();
} catch (InterruptedException e) {
    // Ugh! Who turned on the lights?
    Thread.currentThread().interrupt();
}

And when you're dealing with multiple threads, it's helpful to know that they don't play well with sharing. So when you have shared variables, make sure to use synchronized blocks or atomic variables to prevent tantrums from your threads.

Tips to 'join' the pros

You can get by with just join() in many scenarios, but here are a few additional things you can keep in your developer's backpack:

synchronized keyword: This is your mediating friend who ensures only one thread gets to use the shared resource at a time.
Atomic variables: These are the lockers you get at the gym. Only you can access what's inside your assigned locker, thereby avoiding dreaded concurrency issues.
join() itself is designed to be a team player. It's thread-safe, so calling it on the same thread from multiple threads is not going to create a whole mess of thread spaghetti.
For the more intricate synchronization dances, you might want to get friendly with advanced constructs like CyclicBarriers and CountDownLatch from the java.util.concurrent package.

Handling Interruptions like a 'pro'(grammer)

Why bother with proper handling?

When a thread's join() method gets interrupted, you're gonna want to deal with the situation, akin to capturing a 'try' in rugby. So here are a few pointers:

An InterruptedException signals that another pushy player (thread) tried to muscle in while you were busy. It's often a polite way of saying, "Excuse me, can I cancel that operation?" or "Hey, it's time to close the app!"
A pro move after catching InterruptedException is to re-interrupt the thread, ensuring the rest of the game can continue according to plan.
For the ones that need to power through till the end, encase the join() calls in a loop that will keep going until completion.

Example time!

public void awaitCompletion(Thread thread) {
    boolean completed = false;
    while (!completed) {
        try {
            thread.join();
            completed = true; // The party ended, time to clean up the house 
        } catch (InterruptedException e) {
            // Who burnt the popcorn?
            // Re-interrupt the thread to get back to our movie night
            Thread.currentThread().interrupt();
        }
    }
}