Synchronization

When multiple threads access shared mutable data concurrently, write operations can overlap, causing race conditions. Java uses the synchronized keyword to establish critical sections and enforce mutual exclusion.

Race Condition and Monitor Locks

A race condition occurs when the outcome of execution depends on the exact interleaving of thread execution paths. For example, count++ is not atomic; it consists of three steps: read, update, and write. Two threads running this concurrently can overlap, resulting in one count update being lost.

Every object in Java is associated with an intrinsic monitor lock (often called a monitor). The synchronized keyword requests the monitor lock of a specified object before executing the associated block or method, ensuring mutual exclusion.

Code Walkthrough

The following example simulates a race condition and demonstrates how synchronization fixes it.

class SynchronizedCounter {
    private int count = 0;
// Mutually exclusive critical section
    public synchronized void increment() {
        count++; // Atomic write operation
    }
public synchronized int getCount() {
        return count;
    }
}
public class ConcurrencyDemo {
    public static void main(String[] args) throws InterruptedException {
        SynchronizedCounter counter = new SynchronizedCounter();
Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                counter.increment();
            }
        };
Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
System.out.println("Final count (should be 2000): " + counter.getCount());
    }
}

Interview-Relevant Information