Both volatile and synchronized solve thread safety problems in Java, but their functions are different: 1. volatile ensures the visibility of variables, ensures that read and write directly interact with the main memory under multi-threading, and is suitable for single-time read and write scenarios such as status flags, but does not provide atomicity; 2. synchronized provides atomicity and visibility, and ensures that only one thread executes code block at the same time through mutex locks, which is suitable for composite operations such as count; 3. volatile cannot replace synchronized, and for non-atomic operations, synchronized or concurrent tool classes such as AtomicInteger are still required. Correct selection of tools can ensure thread safety and efficiency.

In Java, thread safety is critical when multiple threads access shared data. Without proper synchronization, programs can exhibit unpredictable behavior due to race conditions, visibility issues, and inconsistent state. Two key tools for managing thread safety are volatile and synchronized . While both help with concurrency, they serve different purposes and are not interchangeable.

Let's break down how each works, when to use them, and what problems they solve.

What Is the volatile Keyword?

The volatile keyword ensures visibility of changes to variables across threads. When a variable is declared volatile , it tells the JVM:

• Writes to this variable are immediately flushed to main memory.
• Reads of this variable always come from main memory, not from a thread's local cache.

This prevents threads from using stale cached values — a common issue in multi-threaded environments.

Example: Using volatile

 public class VolatileExample {
    private volatile boolean running = true;

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // do work
        }
        System.out.println("Stopped");
    }
}

In this example, one thread calls run() and another calls stop() . Without volatile , the run() thread might never see the updated value of running because it could be cached in CPU memory. With volatile , the change is guaranteed to be visible.

When to Use volatile

Use volatile when:

• The variable is read and written by multiple threads.
• The variable does not depend on its previous value (ie, no compound operations like count ).
• You only need visibility , not atomicity.

? Don't use volatile for operations like x — they are not atomic even if the variable is volatile.

What Is the synchronized Keyword?

synchronized provides both mutual exclusion (only one thread can execute the block/method at a time) and visibility (changes made inside the synchronized block are visible to other threads).

It can be applied to:

• Instance methods (locks on the instance)
• Static methods (locks on the class object)
• Code blocks (with a specified lock object)

Example: Using synchronized

 public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count ; // atomic operation due to synchronization
    }

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

Here, synchronized ensures that only one thread can execute increment() or getCount() at a time, preventing race conditions on count .

How synchronized Ensures Visibility

When a thread enters a synchronized block, it acquires the monitor lock and:

• Flushes its local cache.
• Reloads variables from main memory.

When it exits, it writes changes back to main memory. So, like volatile , it guarantees visibility — but with added atomicity.

Key Differences: volatile vs synchronized

Common Pitfalls and Best Practices

• ? Use volatile for state flags (eg, shutdownRequested , initialized ).
• ? Use synchronized when you need atomicity (eg, incrementing, updating multiple variables).
• ? Don't assume volatile makes compound operations safe.
• ? Avoid overusing synchronized — it can cause contention and reduce performance.

Example: Why volatile Isn't Enough for count

 public class BadCounter {
    private volatile int count = 0;

    public void increment() {
        count ; // Not atomic: read, increment, write
    }
}

Even though count is volatile , count involves three steps. Two threads could read the same value, leading to lost updates. You need synchronized or AtomicInteger .

Alternatives: AtomicInteger , ReentrantLock , etc.

For better performance and flexibility, consider:

• AtomicInteger , AtomicLong , etc. — provide atomic operations without blocking.
• java.util.concurrent.locks.ReentrantLock — more control than synchronized .

Example with AtomicInteger :

 private AtomicInteger count = new AtomicInteger(0);

public void increment() {
    count.incrementAndGet(); // thread-safe and efficient
}

Summary

• Use volatile for simple shared flags where you need visibility but not atomicity.
• Use synchronized when you need both atomicity and visibility , especially for compound operations.
• Understand that volatile doesn't replace synchronized — they solve different parts of the concurrency puzzle.

Thread safety isn't just about preventing crashes — it's about ensuring correctness under concurrent access. Choosing the right tool ( volatile , synchronized , or atomic classes) makes your code both safe and efficient.

The above is the detailed content of Thread Safety in Java: A Guide to `volatile` and `synchronized`. For more information, please follow other related articles on the PHP Chinese website!