Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to Inter-Thread Communication in Java — wait(), notify(), notifyAll(), producer-consumer pattern, and how threads coordinate using object monitors.
What is Inter-Thread Communication?
Inter-thread communication allows threads to coordinate their actions — one thread can signal another to wake up and check a condition. Without it, threads would have to use busy-waiting (constantly checking a condition), which wastes CPU.
| Consumer | Is data ready? No. Is data ready? No. Is data ready? No. YES! |
| Consumer | No data? I'll wait()... *sleeping* |
| Producer | Data ready! notify()! |
| Consumer | *wakes up* Got it! Processing... |
The Three Methods: wait(), notify(), notifyAll()
These methods are defined in java.lang.Object (not Thread!):
| Method | Purpose | Must be in | Lock behavior |
|---|---|---|---|
wait() | Thread releases lock and sleeps until notified | synchronized block | Releases lock |
notify() | Wakes up ONE waiting thread | synchronized block | Doesn't release lock immediately |
notifyAll() | Wakes up ALL waiting threads | synchronized block | Doesn't release lock immediately |
Critical Rule: These methods MUST be called from within a synchronized block/method on the SAME object, otherwise you get IllegalMonitorStateException.
Basic wait() and notify() Example
Example
public class WaitNotifyBasic {
private static final Object lock = new Object();
private static String message = null;
public static void main(String[] args) throws InterruptedException {
System.out.println("=== wait() and notify() ===\n");
// Consumer thread — waits for message
Thread consumer = new Thread(() -> {
synchronized (lock) {
System.out.println("[Consumer] Waiting for message...");
while (message == null) { // Always use while, not if!
try {
lock.wait(); // Release lock and sleep
} catch (InterruptedException e) { return; }
}
System.out.println("[Consumer] Got message: " + message);
}
}, "Consumer");
// Producer thread — creates message and notifies
Thread producer = new Thread(() -> {
try { Thread.sleep(2000); } catch (InterruptedException e) { return; }
synchronized (lock) {
message = "Hello from producer!";
System.out.println("[Producer] Message set. Notifying...");
lock.notify(); // Wake up the consumer
}
}, "Producer");
consumer.start();
producer.start();
consumer.join();
producer.join();
System.out.println("\nDone!");
}
}
Output:
Example
=== wait() and notify() ===
[Consumer] Waiting for message...
[Producer] Message set. Notifying...
[Consumer] Got message: Hello from producer!
Done!
How wait/notify Works Internally
| │ Monitor Lock | [currently held by: Consumer] │ |
| │ Wait Set | [] (empty) │ |
| │ Entry Set | [] (empty) │ |
| Step 1 | Consumer calls lock.wait() |
| │ Monitor Lock | [FREE] │ |
| │ Wait Set | [Consumer] ← sleeping here │ |
| │ Entry Set | [] │ |
| Step 2 | Producer acquires lock, calls lock.notify() |
| │ Monitor Lock | [Producer] │ |
| │ Wait Set | [] ← Consumer moved out │ |
| │ Entry Set | [Consumer] ← ready to acquire lock │ |
| Step 3 | Producer exits synchronized, Consumer acquires lock |
| │ Monitor Lock | [Consumer] ← continues execution │ |
| │ Wait Set | [] │ |
| │ Entry Set | [] │ |
Producer-Consumer Pattern
The classic inter-thread communication pattern:
Example
import java.util.*;
public class ProducerConsumer {
private static final int BUFFER_SIZE = 5;
private static Queue<Integer> buffer = new LinkedList<>();
private static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
System.out.println("=== Producer-Consumer Pattern ===");
System.out.println("Buffer size: " + BUFFER_SIZE + "\n");
Thread producer = new Thread(() -> {
for (int i = 1; i <= 10; i++) {
synchronized (lock) {
// Wait while buffer is full
while (buffer.size() == BUFFER_SIZE) {
System.out.println("[Producer] Buffer full! Waiting...");
try { lock.wait(); } catch (InterruptedException e) { return; }
}
buffer.add(i);
System.out.printf("[Producer] Produced: %d | Buffer: %s%n", i, buffer);
lock.notifyAll(); // Wake up consumer
}
try { Thread.sleep(200); } catch (InterruptedException e) { return; }
}
}, "Producer");
Thread consumer = new Thread(() -> {
int consumed = 0;
while (consumed < 10) {
synchronized (lock) {
// Wait while buffer is empty
while (buffer.isEmpty()) {
System.out.println("[Consumer] Buffer empty! Waiting...");
try { lock.wait(); } catch (InterruptedException e) { return; }
}
int item = buffer.poll();
consumed++;
System.out.printf("[Consumer] Consumed: %d | Buffer: %s%n", item, buffer);
lock.notifyAll(); // Wake up producer
}
try { Thread.sleep(350); } catch (InterruptedException e) { return; }
}
}, "Consumer");
producer.start();
consumer.start();
producer.join();
consumer.join();
System.out.println("\n✓ All items produced and consumed!");
}
}
Output:
| Buffer size | 5 |
| [Producer] Produced | 1 | Buffer: [1] |
| [Consumer] Consumed | 1 | Buffer: [] |
| [Producer] Produced | 2 | Buffer: [2] |
| [Producer] Produced | 3 | Buffer: [3] |
| [Consumer] Consumed | 2 | Buffer: [3] |
| [Producer] Produced | 4 | Buffer: [3, 4] |
| [Producer] Produced | 5 | Buffer: [3, 4, 5] |
| [Consumer] Consumed | 3 | Buffer: [4, 5] |
| [Producer] Produced | 6 | Buffer: [4, 5, 6] |
notify() vs notifyAll()
Example
public class NotifyVsNotifyAll {
private static final Object lock = new Object();
private static boolean dataReady = false;
public static void main(String[] args) throws InterruptedException {
System.out.println("=== notify() vs notifyAll() ===\n");
// Create 3 consumer threads
for (int i = 1; i <= 3; i++) {
final int id = i;
new Thread(() -> {
synchronized (lock) {
while (!dataReady) {
System.out.println("[Consumer-" + id + "] Waiting...");
try { lock.wait(); } catch (InterruptedException e) { return; }
}
System.out.println("[Consumer-" + id + "] Data received! Processing.");
}
}, "Consumer-" + i).start();
}
Thread.sleep(500); // Let all consumers start waiting
// Producer notifies
synchronized (lock) {
dataReady = true;
System.out.println("\n[Producer] Data ready! Using notifyAll()");
lock.notifyAll(); // Wakes ALL waiting threads
// lock.notify(); // Would wake only ONE thread!
}
Thread.sleep(500);
System.out.println("\nWith notify(): Only 1 consumer would wake up");
System.out.println("With notifyAll(): All consumers wake up (correct!)");
}
}
Output:
Example
=== notify() vs notifyAll() ===
[Consumer-1] Waiting...
[Consumer-2] Waiting...
[Consumer-3] Waiting...
[Producer] Data ready! Using notifyAll()
[Consumer-1] Data received! Processing.
[Consumer-2] Data received! Processing.
[Consumer-3] Data received! Processing.
Why Always Use while (Not if) with wait()
java example
public class WhileNotIf {
public static void main(String[] args) {
System.out.println("=== Why while, not if ===\n");
System.out.println("❌ WRONG (if):");
System.out.println(" synchronized(lock) {");
System.out.println(" if (buffer.isEmpty()) { // Check ONCE");
System.out.println(" lock.wait();");
System.out.println(" }");
System.out.println(" // BUG: Another thread might have consumed");
System.out.println(" // the item between notify and re-acquiring lock!");
System.out.println(" process(buffer.remove()); // May fail!");
System.out.println(" }");
System.out.println("\n✅ CORRECT (while):");
System.out.println(" synchronized(lock) {");
System.out.println(" while (buffer.isEmpty()) { // RE-CHECK after wake");
System.out.println(" lock.wait();");
System.out.println(" }");
System.out.println(" // Guaranteed: buffer is NOT empty here");
System.out.println(" process(buffer.remove()); // Always safe!");
System.out.println(" }");
System.out.println("\nReasons to use while:");
System.out.println(" 1. Spurious wakeups (JVM may wake thread without notify)");
System.out.println(" 2. Other threads may change state between notify and re-acquire");
System.out.println(" 3. notifyAll() wakes ALL — only one should proceed");
}
}Output
=== Why while, not if === ❌ WRONG (if): May process stale data after spurious wakeup ✓ CORRECT (while): Re-checks condition after every wakeup Always use while loop with wait()!
Real-World Example: Print Queue
Example
import java.util.*;
public class PrintQueue {
private Queue<String> jobs = new LinkedList<>();
private final int MAX_QUEUE = 3;
public synchronized void addJob(String job) throws InterruptedException {
while (jobs.size() >= MAX_QUEUE) {
System.out.println(" [Queue Full] " + Thread.currentThread().getName() + " waiting...");
wait();
}
jobs.add(job);
System.out.println(" [+] " + Thread.currentThread().getName() + " added: " + job + " | Queue: " + jobs);
notifyAll();
}
public synchronized String getJob() throws InterruptedException {
while (jobs.isEmpty()) {
System.out.println(" [Queue Empty] Printer waiting...");
wait();
}
String job = jobs.poll();
System.out.println(" [-] Printer printing: " + job + " | Queue: " + jobs);
notifyAll();
return job;
}
public static void main(String[] args) throws InterruptedException {
PrintQueue queue = new PrintQueue();
System.out.println("=== Print Queue System ===\n");
// Printer thread (consumer)
Thread printer = new Thread(() -> {
for (int i = 0; i < 6; i++) {
try {
String job = queue.getJob();
Thread.sleep(800); // Simulate printing
} catch (InterruptedException e) { return; }
}
}, "Printer");
// Users adding print jobs
Thread user1 = new Thread(() -> {
String[] docs = {"Report.pdf", "Invoice.pdf", "Resume.docx"};
for (String doc : docs) {
try { queue.addJob(doc); Thread.sleep(200); }
catch (InterruptedException e) { return; }
}
}, "User-Alice");
Thread user2 = new Thread(() -> {
String[] docs = {"Photo.jpg", "Slides.pptx", "Email.txt"};
for (String doc : docs) {
try { queue.addJob(doc); Thread.sleep(300); }
catch (InterruptedException e) { return; }
}
}, "User-Bob");
printer.start();
user1.start();
user2.start();
printer.join();
user1.join();
user2.join();
System.out.println("\n✓ All jobs printed!");
}
}
Output
=== Print Queue Demo === [+] Producer-1 added: Job-1 (queue size: 1) [+] Producer-2 added: Job-2 (queue size: 2) [-] Consumer took: Job-1 (queue size: 1) [+] Producer-1 added: Job-3 (queue size: 2) [Queue Full] Producer-2 waiting... [-] Consumer took: Job-2 (queue size: 1) [+] Producer-2 added: Job-4 (queue size: 2)
Common Mistakes
1. Calling wait/notify without synchronized
java example
// ❌ IllegalMonitorStateException!
obj.wait(); // Must be in synchronized(obj)
obj.notify(); // Must be in synchronized(obj)
// ✅ Correct
synchronized (obj) {
obj.wait();
obj.notify();
}2. Using if instead of while with wait
java example
// ❌ Vulnerable to spurious wakeups
if (condition) { lock.wait(); }
// ✅ Always re-check
while (condition) { lock.wait(); }3. Calling notify on wrong object
java example
Object lock1 = new Object();
Object lock2 = new Object();
// Thread A:
synchronized (lock1) { lock1.wait(); }
// Thread B:
synchronized (lock2) { lock2.notify(); } // ❌ Won't wake A! Different object!Interview Questions
Q1: Why are wait(), notify(), notifyAll() in Object class, not Thread class?
Answer: Because every object in Java has an intrinsic lock (monitor). Threads wait ON objects and are notified BY objects. The lock is associated with the object, so the communication methods belong to Object.
Q2: What is the difference between notify() and notifyAll()?
Answer: notify() wakes ONE arbitrary thread from the wait set. notifyAll() wakes ALL threads in the wait set. Use notifyAll() when multiple threads might be waiting for different conditions on the same lock — it's safer.
Q3: Why must wait() be called in a while loop, not an if statement?
Answer: (1) Spurious wakeups — JVM can wake a thread without explicit notify. (2) Between notification and re-acquiring the lock, another thread may have changed the condition. (3) With notifyAll(), multiple threads wake but only one should proceed. The while loop re-checks the condition.
Q4: What happens if you call wait() without holding the object's lock?
Answer: IllegalMonitorStateException is thrown at runtime. wait(), notify(), and notifyAll() MUST be called from within a synchronized block/method on the same object.
Q5: Does notify() release the lock immediately?
Answer: No! The notifying thread continues to hold the lock until it exits the synchronized block. Only then can the notified thread re-acquire the lock and proceed. The notified thread moves from WAITING to BLOCKED (waiting for the lock).
Q6: What is the difference between wait() and sleep()?
Answer: wait() releases the object's lock and waits for notification (used for inter-thread communication). sleep() pauses the current thread for a specified time WITHOUT releasing any locks (just a time delay). wait() is called on an object; sleep() is a Thread static method.
Q8: Why must wait(), notify(), and notifyAll() be called inside synchronized blocks?
A: These methods require the calling thread to own the object's monitor (intrinsic lock). Without synchronization, the thread doesn't hold the monitor, and calling these throws IllegalMonitorStateException. The lock ensures that the condition check and wait/notify happen atomically, preventing race conditions.
Q9: What is a spurious wakeup and how do you handle it?
A: A spurious wakeup is when a thread returns from wait() without being notified or interrupted — it's an allowed JVM implementation behavior. Always check the wait condition in a WHILE loop (not IF): while (!condition) { wait(); }. This re-checks the condition after wakeup, going back to waiting if it was spurious.
Q10: What is the difference between notify() and notifyAll()?
A: notify() wakes ONE arbitrary waiting thread. notifyAll() wakes ALL waiting threads (they then compete for the lock). Use notifyAll() when multiple threads may be waiting for different conditions on the same object. Use notify() only when all waiters are waiting for the same condition and only one can proceed.
Q11: How does BlockingQueue simplify producer-consumer compared to wait/notify?
A: BlockingQueue encapsulates all synchronization internally. put() blocks if full, take() blocks if empty — no manual wait/notify needed. It handles spurious wakeups, monitor management, and condition checking internally. ArrayBlockingQueue, LinkedBlockingQueue, and PriorityBlockingQueue are common implementations.
Q12: What is the difference between wait() and sleep() in inter-thread communication?
A: wait(): releases the lock, waits for notify, used for thread coordination. sleep(): does NOT release any lock, pauses for fixed time, used for timing delays. wait() is for communication between threads; sleep() is for pausing a single thread independently.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Inter-Thread Communication in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, multithreading, inter, thread
Related Java Master Course Topics
Continue learning this concept
MultithreadingCreating Threads in JavaComplete guide to creating threads in Java — extending Thread class, implementing Runnable interface, lambda expressions, comparison of approaches, and when to use each method.MultithreadingDaemon Threads in JavaComplete guide to Daemon Threads in Java — what they are, how they differ from user threads, JVM shutdown behavior, practical use cases like GC and auto-save, and common pitfalls.MultithreadingThread Class in JavaComplete guide to the Thread class in Java — constructors, important methods (sleep, join, yield, interrupt), thread naming, thread groups, and practical usage patterns.MultithreadingThread IntroductionComplete introduction to Multithreading in Java — what threads are, processes vs threads, why multithreading matters, concurrency vs parallelism, and how the JVM manages threads.MultithreadingThread Life Cycle in JavaComplete guide to Thread Life Cycle states in Java — NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED, state transitions, and how to observe thread states programmatically.MultithreadingThread Priority in JavaComplete guide to Thread Priority in Java — priority constants, setting priorities, how the thread scheduler uses priorities, priority inheritance, and why priorities are unreliable for correctness.