Synchronization

When multiple threads read and modify shared data at the same time without coordination, you get a race condition: the final result depends on the unpredictable timing of thread execution, and it is often wrong. Synchronization is Java's built-in mechanism for making sure only one thread at a time can execute a critical section of code that touches shared, mutable state.

Why it matters

When two threads change the same data without coordination, updates get lost. The program does not crash; it just produces a slightly wrong number, and a different wrong number on the next run. Synchronization is the basic tool that makes a shared operation happen as one uninterrupted step.

Intrinsic Locks (Monitors)

Every Java object carries a hidden intrinsic lock, also called a monitor. The synchronized keyword tells the JVM that a thread must acquire an object's monitor before entering the guarded code, and must release it on exit (even if an exception is thrown). Only one thread can hold a given object's monitor at a time; any other thread that tries to enter a block synchronized on the same object is placed in the BLOCKED state until the lock is released.

Synchronized Methods vs Synchronized Blocks

Marking an entire method synchronized locks on this (for instance methods) or on the class object itself (for static methods), for the full duration of the call. A synchronized block, synchronized (lockObject) { ... }, lets you lock on a specific object and guard only the minimal section of code that actually needs protection, which reduces contention and improves throughput compared to synchronizing an entire method unnecessarily.

• Synchronized method: public synchronized void increment() { ... } — simple, but locks for the whole method body.
• Synchronized block: synchronized (this) { count++; } — precise, locks only what needs protecting.
• Static synchronized methods lock on the Class object, which is a different lock than any instance lock.

Race Condition, With and Without Synchronization

A classic example is two threads both executing count++ on a shared counter. That single line is actually three steps at the bytecode level — read the value, add one, write it back — and if two threads interleave those steps, one increment can be lost. Wrapping the increment in a synchronized block (or method) forces the read-modify-write sequence to complete atomically from the perspective of other threads, eliminating the lost update.

Example

public class SynchronizationDemo {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public static void main(String[] args) throws InterruptedException {
        SynchronizationDemo demo = new SynchronizationDemo();

        Runnable task = () -> {
            for (int i = 0; i < 100000; i++) {
                demo.increment();
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();

        System.out.println("Final count: " + demo.count);
    }
}

Final count: 200000
(Without the "synchronized" keyword on increment(), this total is frequently LESS than 200000
because of lost updates from unsynchronized concurrent access — the exact wrong value varies per run.)

Exercise

Two threads each call increment() 10,000 times, but the program usually prints less than 20000 because count++ is not atomic. Make the counter thread-safe.

Expected output: 20000

class Counter {
    private int count = 0;

    void increment() {
        count++;
    }

    int get() {
        return count;
    }
}

public class RaceFix {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        };

        Thread first = new Thread(task);
        Thread second = new Thread(task);
        first.start();
        second.start();
        first.join();
        second.join();

        System.out.println(counter.get());
    }
}

class Counter {
    private int count = 0;

    synchronized void increment() {
        count++;
    }

    synchronized int get() {
        return count;
    }
}

public class RaceFix {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Runnable task = () -> {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        };

        Thread first = new Thread(task);
        Thread second = new Thread(task);
        first.start();
        second.start();
        first.join();
        second.join();

        System.out.println(counter.get()); // 20000
    }
}

Quick quiz

Interview questions