挥发性(vɒlətʌɪl):在常温下容易挥发

关于volatile的重要一点:

Synchronization in Java is possible by using Java keywords synchronized and volatile and locks. In Java, we can not have synchronized variable. Using synchronized keyword with a variable is illegal and will result in compilation error. Instead of using the synchronized variable in Java, you can use the java volatile variable, which will instruct JVM threads to read the value of volatile variable from main memory and don’t cache it locally. If a variable is not shared between multiple threads then there is no need to use the volatile keyword.

源

volatile用法示例:

public class Singleton {
    private static volatile Singleton _instance; // volatile variable
    public static Singleton getInstance() {
        if (_instance == null) {
            synchronized (Singleton.class) {
                if (_instance == null)
                    _instance = new Singleton();
            }
        }
        return _instance;
    }
}

我们在第一个请求到来时惰性地创建实例。

如果我们不使_instance变量为volatile，那么创建Singleton实例的线程就不能与其他线程通信。因此，如果线程A正在创建单例实例，在创建后，CPU损坏等，所有其他线程将无法看到_instance的值不为空，他们将认为它仍然被分配为空。

为什么会发生这种情况?因为读线程不做任何锁，直到写线程从同步块中出来，内存不会被同步，_instance的值也不会在主存中更新。使用Java中的Volatile关键字，这是由Java本身处理的，这样的更新将对所有读取线程可见。

结论:volatile关键字也用于线程之间的内存内容通信。

without volatile的用法示例:

public class Singleton {    
    private static Singleton _instance;   //without volatile variable
    public static Singleton getInstance() {   
        if (_instance == null) {  
            synchronized(Singleton.class) {  
                if (_instance == null) 
                    _instance = new Singleton(); 
            } 
        }
        return _instance;  
    }
}

The code above is not thread-safe. Although it checks the value of instance once again within the synchronized block (for performance reasons), the JIT compiler can rearrange the bytecode in a way that the reference to the instance is set before the constructor has finished its execution. This means the method getInstance() returns an object that may not have been initialized completely. To make the code thread-safe, the keyword volatile can be used since Java 5 for the instance variable. Variables that are marked as volatile get only visible to other threads once the constructor of the object has finished its execution completely. Source

Java中不稳定的用法:

快速失败迭代器通常使用list对象上的volatile计数器实现。

当列表更新时，计数器会递增。 创建Iterator时，计数器的当前值嵌入到Iterator对象中。 当执行Iterator操作时，该方法比较两个计数器值，如果不相同则抛出ConcurrentModificationException异常。

故障安全迭代器的实现通常是轻量级的。它们通常依赖于特定列表实现的数据结构的属性。没有一般的模式。

…volatile修饰符保证任何读取字段的线程都能看到最近写入的值。——乔希·布洛赫 如果您正在考虑使用volatile，请仔细阅读java.util.concurrent包，它处理原子行为。 维基百科上关于单例模式的帖子显示了volatile的使用。

用volatile关键字声明的变量有两个主要特性，这使得它很特殊。

如果我们有一个易失性变量，它不能被任何线程缓存到计算机的(微处理器)缓存内存中。访问总是发生在主存中。 如果对一个易失性变量正在进行写操作，并且突然请求了一个读操作，那么可以保证写操作将在读操作之前完成。

以上两个品质推断了这一点

所有读取volatile变量的线程肯定会读取最新的值。因为没有缓存值可以污染它。而且读请求只有在当前写操作完成后才会被授予。

另一方面，

如果我们进一步研究我提到的#2，我们可以看到volatile关键字是维护一个共享变量的理想方法，它有n个读线程，只有一个写线程可以访问它。一旦我们添加了volatile关键字，就完成了。没有任何线程安全方面的开销。

交谈,

我们不能仅仅使用volatile关键字来满足有多个写入线程访问它的共享变量。

绝对是的。(不仅是Java, c#也是如此。)有时，您需要获取或设置一个值，该值保证是给定平台上的原子操作，例如int或boolean，但不需要线程锁定的开销。volatile关键字允许您确保在读取值时获得的是当前值，而不是在另一个线程上写入时被废弃的缓存值。

对于长变量和双变量类型的读写操作的处理，目前还没有人提及。读和写对于引用变量和大多数基本变量都是原子操作，长变量和双变量类型除外，它们必须使用volatile关键字作为原子操作。@link

Volatile具有内存可见性的语义。基本上，volatile字段的值在写操作完成后对所有读取器(特别是其他线程)可见。如果没有volatile，读者可以看到一些未更新的值。

回答您的问题:是的，我使用一个volatile变量来控制某些代码是否继续循环。循环测试易变值，如果为真则继续。可以通过调用“stop”方法将条件设置为false。循环看到false，并在stop方法完成执行后测试该值时终止。

我强烈推荐的《Java并发实践》一书对volatile做了很好的解释。这本书的作者与问题中提到的IBM文章的作者是同一人(事实上，他在那篇文章的末尾引用了他的书)。我对volatile的使用被他的文章称为“模式1状态标志”。

如果您想了解更多关于volatile在底层是如何工作的，请阅读Java内存模型。如果你想超越这个层次，看看像Hennessy & Patterson这样的优秀计算机体系结构书籍，阅读关于缓存一致性和缓存一致性的内容。