Java Multithreading: Understanding wait() and notify() in Java
Table of Contents
- Introduction
- Understanding wait() and notify() Methods
- Java Example: Bank Account Simulation
- Code Walkthrough
- Advantages and Use Cases
- Conclusion
Introduction
In Java multithreading, the methods wait() and notify() play a critical role in enabling thread communication. These methods are used to coordinate activities between threads, especially when one thread depends on another thread’s actions. For example, a thread waiting for a resource update can pause its execution until the resource is updated by another thread, using these methods. In this article, we’ll dive into the fundamentals of wait() and notify(), supported by a practical example of bank transactions to illustrate the concepts.
Understanding wait() and notify() Methods
The wait() and notify() methods are part of the Object class, which means every Java object has the capability to call these methods. These methods help manage the execution of threads by temporarily halting a thread’s execution until it is resumed by another thread.
Key Concepts:
- wait(): Halts the execution of a thread until another thread invokes the notify() method on the same object.
- notify(): Wakes up a single thread that is waiting on an object’s wait() method.
Comparison Between wait() and notify():
| Feature | wait() | notify() |
|---|---|---|
| Purpose | Pauses thread execution | Wakes up waiting threads |
| Thread behavior | Thread remains in waiting state | Resumes one waiting thread |
| Condition | Used when a condition isn’t met | Used when the condition changes |
Java Example: Bank Account Simulation
In the following example, we simulate a bank account where one thread attempts to withdraw money, but it must wait until another thread deposits money into the account.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
package org.studyeasy; public class Main { public static int balance = 0; public synchronized void withdraw(int amount) throws InterruptedException { if(balance <= 0) { System.out.println("Waiting for balance to be updated"); wait(); // Thread waits until balance is updated } balance = balance - amount; System.out.println("The current balance is " + balance); } public synchronized void deposit(int amount) { System.out.println("Depositing " + amount); balance = balance + amount; notify(); // Notifies the waiting thread } public static void main(String[] args) { Main main = new Main(); // Thread for withdrawing money Thread thread1 = new Thread(() -> { try { main.withdraw(1000); } catch (InterruptedException e) { e.printStackTrace(); } }); thread1.setName("Withdrawal Thread"); // Thread for depositing money Thread thread2 = new Thread(() -> main.deposit(2000)); thread2.setName("Deposit Thread"); // Start threads thread1.start(); thread2.start(); } |
Code Walkthrough
- Withdrawal Thread: This thread attempts to withdraw money from the balance. If the balance is zero or negative, the thread waits using the wait() method until notified by the deposit thread.
- Deposit Thread: This thread deposits money into the account and calls the notify() method, waking up the waiting withdrawal thread.
Here’s a breakdown of the critical operations:
- wait(): If the balance is insufficient, the withdrawal thread waits.
- notify(): The deposit thread deposits the amount and then notifies the waiting thread that the balance has been updated.
- Synchronization: Both methods withdraw() and deposit() are synchronized to ensure thread-safe operations on the shared resource balance.
Output of the Program:
|
1 2 3 |
Waiting for balance to be updated Depositing 2000 The current balance is 1000 |
Advantages and Use Cases
The use of wait() and notify() is particularly useful when:
- Inter-thread Communication: Threads need to communicate or share information. For instance, in producer-consumer scenarios where one thread produces data, and another consumes it.
- Synchronization: These methods provide a way to achieve thread synchronization when dealing with shared resources.
When to Use:
- When a thread depends on a condition that another thread modifies.
- In scenarios requiring multiple threads to coordinate their actions.
Conclusion
The wait() and notify() methods in Java offer powerful mechanisms for thread coordination. By allowing threads to communicate efficiently, they help prevent race conditions and ensure data integrity when working with shared resources. The practical example of a bank account simulation demonstrates the real-world applications of these methods, making them a must-know for any Java developer working with multithreading.