What is the difference between volatile and synchronized?

volatile makes changes to a variable visible across threads. In other words, if you have 100 threads, and thread 57 updates a volatile variable, then the other threads will see the latest value instead of working with an old cached copy.

But volatile does not stop multiple threads from updating the value at the same time. So if several threads are modifying the variable together, you can still get race conditions and lost updates.

synchronized also gives visibility guarantees, but it adds mutual exclusion too: only one thread can enter the synchronized block at a time.

Meaning that while one thread is updating the protected value, another thread cannot enter and modify it simultaneously. That is why synchronized can protect critical sections and keep multi-step operations consistent.

In single-threaded code, when you update a variable, the next line of code sees the update. Simple.

In multi-threaded code, one thread changing a value does not automatically mean every other thread immediately sees the newest value.

volatile is useful for a simple flag where one thread signals another thread to stop.

class Worker {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // do work
        }
    }
}

Here, volatile is enough because reading and writing a boolean flag is simple. We only need visibility.

volatile does not make compound operations atomic.

private volatile int count = 0;

public void increment() {
    count++;
}

This looks like one operation, but it is actually a read, modify, and write.

Use synchronized when a block of code must be protected so only one thread can execute it at a time.

class Counter {
    private int count = 0;

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

    public synchronized int getCount() {
        return count;
    }
}

Now increment is protected. One thread enters, updates the value, and exits. Another thread cannot enter that method at the same time.