Thread Coordination with wait/notify

Thread Coordination with wait() and notify()

Welcome back to our advanced Java concurrency course! In previous lessons, we explored lock mechanisms and deadlock prevention. Now, we will focus on thread coordination using the wait() and notify() methods in Java, a powerful approach to managing inter-thread communication.

What You'll Learn

In this lesson, you will: Learn how to implement thread coordination using the wait() and notify() methods. Understand how to synchronize threads for correct execution order. Apply countdown logic to real-world scenarios involving thread dependencies. By the end of this lesson, you’ll be able to use wait() and notify() to coordinate thread activities effectively, improving the performance and reliability of your concurrent applications.

Understanding Thread Coordination with wait() and notify()

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Coordinating Multiple Threads with wait() and notify()

Now that we have an understanding of the countdown mechanism, let's see how it is used to coordinate two threads. One thread will wait for the countdown, while the other will perform the countdown and notify the waiting thread.

Java

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Countdown countdown = new Countdown();

        // Thread that waits for the countdown
        Thread waiter = new Thread(() -> {
            try {
                countdown.waitForCountdown();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Thread that performs the countdown
        Thread notifier = new Thread(() -> {
            try {
                countdown.startCountdown();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        waiter.start();
        Thread.sleep(1000); // Ensure the waiting thread starts first
        notifier.start();

        waiter.join();
        notifier.join();
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Countdown countdown = new Countdown();

        // Thread that waits for the countdown
        Thread waiter = new Thread(() -> {
            try {
                countdown.waitForCountdown();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Thread that performs the countdown
        Thread notifier = new Thread(() -> {
            try {
                countdown.startCountdown();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        waiter.start();
        Thread.sleep(1000); // Ensure the waiting thread starts first
        notifier.start();

        waiter.join();
        notifier.join();
    }
}

In this example:

Two threads are created: one that waits (waiter) and one that performs the countdown (notifier).
A short delay (Thread.sleep(1000)) ensures that the waiter starts before the countdown begins, ensuring correct order of execution.
The join() method is used to ensure both threads finish before the program terminates, ensuring a clean and controlled shutdown.

Running the above code results in the following output:

Waiting for countdown...
Countdown started...
Countdown finished! Notified waiting thread.
Countdown complete! Proceeding...

Waiting for countdown...
Countdown started...
Countdown finished! Notified waiting thread.
Countdown complete! Proceeding...

Here’s what happens:

Thread waiter starts first and immediately calls the waitForCountdown() method. Since isReady is false, the wait() method is called, causing the thread to wait.
After a brief delay of 1 second, thread notifier starts and calls the startCountdown() method. It simulates a countdown by sleeping for 2 seconds, then sets isReady to true and calls notify() to wake the waiting thread.
Once the waiting thread is notified, it resumes, completing its task and printing "Countdown complete! Proceeding...".