…volatile修饰符保证任何读取字段的线程都能看到最近写入的值。——乔希·布洛赫 如果您正在考虑使用volatile，请仔细阅读java.util.concurrent包，它处理原子行为。 维基百科上关于单例模式的帖子显示了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只保证所有线程，甚至线程本身，都是递增的。例如:计数器在同一时间看到变量的同一面。它不是用来代替同步或原子或其他东西，它完全使读取同步。请不要将其与其他java关键字进行比较。如下例所示，volatile变量操作也是原子性的，它们会立即失败或成功。

package io.netty.example.telnet;

import java.util.ArrayList;
import java.util.List;

public class Main {

    public static volatile  int a = 0;
    public static void main(String args[]) throws InterruptedException{

        List<Thread> list = new  ArrayList<Thread>();
        for(int i = 0 ; i<11 ;i++){
            list.add(new Pojo());
        }

        for (Thread thread : list) {
            thread.start();
        }

        Thread.sleep(20000);
        System.out.println(a);
    }
}
class Pojo extends Thread{
    int a = 10001;
    public void run() {
        while(a-->0){
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Main.a++;
            System.out.println("a = "+Main.a);
        }
    }
}

即使你放不放，结果也总会不一样。但是，如果您像下面那样使用AtomicInteger，结果将始终相同。同步也是如此。

    package io.netty.example.telnet;

    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;

    public class Main {

        public static volatile  AtomicInteger a = new AtomicInteger(0);
        public static void main(String args[]) throws InterruptedException{

            List<Thread> list = new  ArrayList<Thread>();
            for(int i = 0 ; i<11 ;i++){
                list.add(new Pojo());
            }

            for (Thread thread : list) {
                thread.start();
            }

            Thread.sleep(20000);
            System.out.println(a.get());

        }
    }
    class Pojo extends Thread{
        int a = 10001;
        public void run() {
            while(a-->0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Main.a.incrementAndGet();
                System.out.println("a = "+Main.a);
            }
        }
    }

是的，当你想要一个可变变量被多个线程访问时，必须使用volatile。这不是很常见的用例，因为通常你需要执行不止一个原子操作(例如，在修改变量之前检查变量状态)，在这种情况下，你会使用同步块代替。

假设一个线程修改了一个共享变量的值，如果你没有对该变量使用volatile修饰符的话。当其他线程想要读取这个变量的值时，它们看不到更新后的值，因为它们是从CPU的缓存而不是RAM内存中读取变量的值。这个问题也被称为能见度问题。

通过将共享变量声明为volatile，所有对计数器变量的写入都将立即写入主存。同样，所有对counter变量的读取都将直接从主存中读取。

public class SharedObject {
    public volatile int sharedVariable = 0;
}

对于非易失性变量，不能保证Java虚拟机(JVM)何时将数据从主存读取到CPU缓存，或何时将数据从CPU缓存写入主存。这可能会导致几个问题，我将在下面的部分中解释这些问题。

例子:

想象这样一种情况，两个或多个线程可以访问一个共享对象，该对象包含一个声明如下的计数器变量:

public class SharedObject {
    public int counter = 0;
}

再想象一下，只有线程1增加计数器变量，但是线程1和线程2都可以不时地读取计数器变量。

如果计数器变量没有被声明为volatile，则不能保证计数器变量的值何时从CPU缓存写入主存。这意味着CPU缓存中的计数器变量值可能与主存中的不相同。这种情况如下所示:

线程看不到一个变量的最新值，因为它还没有被另一个线程写回主存，这个问题被称为“可见性”问题。一个线程的更新对其他线程是不可见的。

volatile关键字有两种不同的用法。

阻止JVM从寄存器(假设为缓存)读取值，并强制从内存读取其值。 降低内存不一致错误的风险。

阻止JVM读取寄存器中的值，并强制其读取 从内存中读取的值。

busy标志用于防止线程在设备繁忙且该标志不受锁保护的情况下继续运行:

while (busy) {
    /* do something else */
}

当另一个线程关闭busy标志时，测试线程将继续执行:

busy = 0;

但是，由于busy在测试线程中经常被访问，JVM可以通过将busy的值放在寄存器中来优化测试，然后在每次测试之前测试寄存器的内容，而不读取内存中的busy值。测试线程永远不会看到busy的变化，而另一个线程只会改变内存中的busy值，从而导致死锁。将busy标志声明为volatile将强制在每次测试之前读取它的值。

降低内存一致性错误的风险。

使用易失性变量可以降低内存一致性错误的风险，因为对易失性变量的任何写入都会建立一个 “happens-before”关系与该变量的后续读取之间的关系。这意味着对volatile变量的更改总是对其他线程可见。

这种读写而不产生记忆一致性错误的技术被称为原子动作。

原子作用是指有效地同时发生的作用。原子的动作不可能中途停止:它要么完全发生，要么根本不发生。在操作完成之前，原子操作的副作用是不可见的。

下面是你可以指定的原子操作:

对于引用变量和大多数变量来说，读和写都是原子的 基本变量(所有类型，除了long和double)。 对于所有声明为volatile的变量，读和写都是原子的 (包括长变量和双变量)。

干杯!