挥发性(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'关键字或'synchronized'以及您可能拥有的任何其他并发控制工具和技术。桌面应用就是这样一个例子。

If you are developing an application that would be deployed to application server (Tomcat, JBoss AS, Glassfish, etc) you don't have to handle concurrency control yourself as it already addressed by the application server. In fact, if I remembered correctly the Java EE standard prohibit any concurrency control in servlets and EJBs, since it is part of the 'infrastructure' layer which you supposed to be freed from handling it. You only do concurrency control in such app if you're implementing singleton objects. This even already addressed if you knit your components using frameworkd like Spring.

因此，在Java开发的大多数情况下，应用程序是一个web应用程序，并使用IoC框架，如Spring或EJB，你不需要使用'volatile'。

从oracle文档页，需要volatile变量来修复内存一致性问题:

使用易失性变量可以降低内存一致性错误的风险，因为对易失性变量的任何写入都会与该变量的后续读取建立happens-before关系。

这意味着对volatile变量的更改总是对其他线程可见。这也意味着当线程读取一个volatile变量时，它不仅看到了volatile的最新更改，还看到了导致更改的代码的副作用。

正如在Peter Parker的回答中解释的那样，在没有volatile修饰符的情况下，每个线程的堆栈都可能有自己的变量副本。通过将变量设置为volatile，可以修复内存一致性问题。

为了更好地理解，请查看jenkov教程页面。

看一下相关的SE问题，了解更多关于volatile的细节和使用volatile的用例:

Java中volatile和synchronized的区别

一个实际的用例:

你有很多线程，它们需要以特定的格式打印当前时间，例如:java.text.SimpleDateFormat("HH-mm-ss")。可以有一个类，它将当前时间转换为SimpleDateFormat，并每一秒更新一次变量。所有其他线程都可以使用这个易失性变量在日志文件中打印当前时间。

Volatile变量是轻量级同步。当所有线程之间的最新数据可见性是必需的，并且原子性可能会受到损害时，在这种情况下，Volatile变量必须是首选。对volatile变量的读取总是返回任何线程最近完成的写操作，因为它们既不缓存在寄存器中，也不缓存在其他处理器看不到的缓存中。Volatile是无锁的。当场景满足上面提到的条件时，我使用volatile。

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

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

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

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

另一方面，

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

交谈,

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

如果您有一个多线程系统，这些多线程处理一些共享数据，这些线程将在它们自己的缓存中加载数据。如果我们不锁定资源，在一个线程中所做的任何更改都不会在另一个线程中可用。

使用锁定机制，我们可以添加对数据源的读/写访问。如果一个线程修改了数据源，该数据将存储在主存中而不是它的缓存中。当其他线程需要这个数据时，它们将从主存中读取它。这将显著增加延迟。

为了减少延迟，我们将变量声明为volatile。这意味着无论何时变量的值在任何处理器中被修改，其他线程都将被迫读取它。它仍然有一些延迟，但比从主存中读取要好。