在Java中，volatile關(guān)鍵字用于確保多線程環(huán)境下變量的可見性，其核心用途是保證讀取時(shí)能獲取最新的寫入值。當(dāng)一個(gè)變量被聲明為volatile時(shí)，JVM會禁止該變量在各線程中的本地緩存，強(qiáng)制所有讀寫操作都發(fā)生在主內(nèi)存中，從而避免因緩存不一致導(dǎo)致的線程間通信問題。它適用于以下場景：1. 變量被多個(gè)線程訪問；2. 變量的更新不依賴當(dāng)前值（如不涉及自增等復(fù)合操作）；3. 不需要原子性保障的情況。典型用例包括狀態(tài)標(biāo)志、一次性安全發(fā)布和弱狀態(tài)同步。與synchronized不同，volatile僅提供可見性和有序性保證，而不提供原子性和互斥訪問能力。需要注意的是，volatile無法確保像count 這樣的復(fù)合操作的原子性，也不能替代全面的同步機(jī)制，因此在涉及多個(gè)線程同時(shí)修改共享變量的情況下，應(yīng)考慮使用synchronized或AtomicInteger等更高級的并發(fā)控制手段。

In Java, the volatile keyword is used to indicate that a variable's value may be modified by different threads. When a variable is declared as volatile, it ensures that any read of that variable will see the most recent write to it, even if those reads and writes occur on different threads.

Visibility Across Threads

One of the main reasons to use volatile is to ensure visibility of changes across threads. Without volatile, each thread might keep its own copy of a variable in local memory (like CPU cache), which can lead to stale data being read.

For example, imagine one thread updating a boolean flag while another thread checks it in a loop. If the flag isn't volatile, the second thread might never see the updated value because it keeps reading from its cached version.

Declaring the flag like this:

private volatile boolean running = true;

tells the JVM not to cache the value locally and always read it from main memory, ensuring up-to-date visibility.

When to Use Volatile

You should consider using volatile when:

• The variable is accessed by multiple threads.
• The variable does not depend on its current value for updates (i.e., no compound actions like incrementing).
• You don’t need atomicity for operations like i , since volatile doesn’t provide that.

Some typical use cases include:

• Status flags (e.g., shutdownRequested)
• One-time safe publication (e.g., initializing an object reference)
• Weak state synchronization where full locking is unnecessary

If your usage involves more complex operations or dependencies between variables, you're better off using synchronized blocks or classes from java.util.concurrent.

How It Differs From Synchronized

While both synchronized and volatile are used for thread safety, they work differently:

• synchronized provides both mutual exclusion (only one thread can execute a block at a time) and visibility guarantees.
• volatile only provides visibility and ordering guarantees but not atomicity.

So, if you just need to make sure threads see the latest value and there’s no critical section or locking needed, volatile can be lighter weight than synchronized.

Also, entering and exiting a synchronized block establishes a happens-before relationship, similar to how a write to a volatile variable happens before a subsequent read.

Limitations to Be Aware Of

It's important to understand what volatile cannot do:

• It won't make compound operations like count atomic — those still require synchronization.
• It doesn’t lock the variable; other threads can still modify it concurrently.
• It's not a replacement for proper synchronization in all scenarios.

For instance, if two threads both try to update a volatile int counter, you can still end up with race conditions. In such cases, using AtomicInteger or synchronized methods would be better.

So, think carefully about whether your shared variable truly fits into the simple pattern that volatile supports.

基本上就這些。

以上是Java中的'揮發(fā)性”關(guān)鍵字是什么？的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！