Understanding Java Monitors: How Thread Synchronization Works

What is a Monitor?

In Java, a monitor is a mechanism used to implement thread synchronization. Every Java object has an associated monitor, and threads acquire and release it using the synchronized keyword, ensuring that only one thread can execute a synchronized block or method at a time.

Components of a Monitor

A monitor typically consists of three key parts:

Entry List : the set of threads waiting to acquire the monitor lock.

Owner Thread : the thread that currently holds the monitor lock.

Wait Set : the set of threads that have called wait() and are waiting to be notified.

Where Threads Wait

Entry List : Threads that attempt to enter a synchronized block or method but cannot obtain the monitor lock are placed here and remain blocked.

Wait Set : Threads that invoke wait() release the monitor lock and enter this set, staying waiting until another thread calls notify() or notifyAll().

Thread State Transition Diagram

The following outlines the transitions between thread states:

New : Thread is created but not yet started.

Runnable : Thread has started and may be running.

Blocked : Thread is in the entry list, waiting for the monitor lock.

Waiting : Thread is in the wait set, awaiting notification via notify() or notifyAll().

Timed Waiting : Thread is in the wait set with a timeout.

Terminated : Thread has completed execution.

Example Code Explanation

The example below demonstrates how threads move between these states using a shared lock object.

public class MonitorExample {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("Thread 1: Acquired lock, entering wait state.");
                    lock.wait();
                    System.out.println("Thread 1: Woken up, reacquired lock.");
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Thread 2: Acquired lock, notifying.");
                lock.notify();
                System.out.println("Thread 2: Notified, releasing lock.");
            }
        });

        thread1.start();
        try {
            Thread.sleep(100); // Ensure thread1 starts first and enters wait state
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        thread2.start();
    }
}

Process Explanation

Thread 1 acquires the monitor lock : Enters the synchronized block and obtains the lock.

Calls lock.wait(): Releases the monitor lock and moves to the wait set.

Thread 2 acquires the monitor lock : Enters its synchronized block while Thread 1 is waiting.

Calls lock.notify(): Wakes up one thread in the wait set (Thread 1).

Thread 2 exits the synchronized block, releasing the monitor lock.

Thread 1 re-acquires the monitor lock : After being notified, it competes for the lock, regains it, and continues execution after wait() returns.

Summary

Monitor : Used for thread synchronization; each Java object has one.

Entry List : Threads waiting to acquire the monitor lock.

Wait Set : Threads that have called wait() and are waiting to be notified.

State Transitions : Threads move among New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated states.