Java中的線程安全：'揮發性”和'同步”指南

volatile和synchronized在Java中都解決線程安全問題，但作用不同：1. volatile保證變量的可見性，確保多線程下讀寫直接與主內存交互，適用於狀態標誌等單次讀寫場景，但不提供原子性；2. synchronized提供原子性和可見性，通過互斥鎖確保同一時間只有一個線程執行代碼塊，適用於復合操作如count ；3. volatile不能替代synchronized，對於非原子操作仍需synchronized或使用AtomicInteger等並發工具類，正確選擇工具可確保線程安全且高效。

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.

以上是Java中的線程安全：'揮發性”和'同步”指南的詳細內容。更多資訊請關注PHP中文網其他相關文章！