Java中挥发性关键字的功能是什么？

volatile关键字确保变量的读写直接与主内存交互，1. 保证多线程间变量修改的可见性，如flag标志位的及时感知；2. 通过happens-before规则防止指令重排序；3. 不提供原子性，如i++需额外同步；4. 适用于单一写线程、多读线程且无复合操作的场景，如控制线程运行的布尔标志，它确保状态发布安全但不能替代锁机制。

The volatile keyword in Java is used to ensure that a variable's value is always read from and written to main memory, rather than being cached in a thread's local stack or CPU cache. This guarantees visibility of changes across threads, making it a lightweight synchronization mechanism for specific use cases.

Ensures Visibility Across Threads

When a variable is declared volatile, every read of that variable is guaranteed to see the most recent write by any thread. Without volatile, each thread may cache the variable's value locally, leading to situations where one thread doesn't see updates made by another.

For example:

public class VolatileExample {
    private volatile boolean flag = false;

    public void writer() {
        flag = true; // This change will be immediately visible to other threads
    }

    public void reader() {
        while (!flag) {
            // Keep waiting until flag becomes true
        }
        // Proceed when flag is true
    }
}

Here, the volatile keyword ensures that when one thread calls writer(), the change to flag is immediately visible to the thread running reader().

Prevents Reordering (Partial Ordering Guarantee)

The volatile keyword also adds a happens-before relationship, which prevents the compiler and processor from reordering instructions around the volatile read/write in a way that could break correctness in multithreaded contexts.

This means:

• All writes to variables (non-volatile too) that happen before a write to a volatile variable are guaranteed to be visible to any thread that reads the volatile variable afterward.
• All reads that happen after a read of a volatile variable will see the updated values from before the volatile write in another thread.

What volatile does NOT do

It's important to understand what volatile doesn't provide:

• ❌ Atomicity: Operations like i++ (which involves read, modify, write) are not atomic even on a volatile variable.
• ❌ Full mutual exclusion: It doesn’t replace synchronized or java.util.concurrent locks when you need to protect a block of code or compound operations.

For example:

volatile int counter = 0;

void increment() {
    counter++; // Not atomic — volatile won't help here
}

This can still result in lost updates under concurrency.

When to use volatile

Use volatile when:

• ✅ The variable is a simple flag (e.g., shutdownRequested)
• ✅ Only one thread writes to the variable, and others only read
• ✅ You don’t perform compound operations (like read-modify-write) on the variable
• ✅ You need immediate visibility of changes across threads

Common use case:

private volatile boolean running = true;

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

public void stop() {
    running = false; // Another thread can safely call this
}

In summary, volatile ensures visibility and ordering but not atomicity. It’s useful for safe publication of shared state and flags, but not a replacement for full synchronization when multiple operations need to be coordinated.

以上是Java中挥发性关键字的功能是什么？的详细内容。更多信息请关注PHP中文网其他相关文章！