我们都知道，在 Java 中有很多的关键字，比如 synchronize 比如 volatile ，这些都是一些比较关键的，还有 final ，今天我们就来聊一下这个 volatile 因为这个 volatile 是经常在面试中会问到的，虽然开发不常用，但是面试常用，我们也是需要掌握的。

Java内存模型的特性

Java内存模型（Java Memory Model，JMM）定义了程序中各个变量（包括实例字段、静态字段和构成数组对象的元素）的访问方式，主要围绕并发编程时的原子性、可见性和有序性这三个特征。

原子性（Atomicity）

原子性是指一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。在Java中，对基本数据类型的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行完成，要么就不执行。但是，对于更大的操作，比如自增操作（i++），就不是原子性的了，因为它实际上包含了三个步骤：读取i的值，对值加1，然后将结果写回。这就可能导致在多线程环境下出现问题。然而，Java内存模型只保证了基本读取和赋值的原子性，对于复合操作，需要使用其他的同步机制来保证原子性。

可见性（Visibility）

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。Java内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的。此外，Java还提供了volatile关键字来实现可见性。当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主内存，当其他线程需要读取时，它会去主内存中读取新值。这就保证了其他线程可以立即看到这个修改。

有序性（Ordering）

Java内存模型中的有序性指的是在并发时，程序的执行顺序应该按照代码的先后顺序执行。但是，由于重排序的存在，即编译器和处理器为了提高程序性能可能会对输入代码进行优化，他们可以不按照代码中的顺序执行语句，这就可能导致程序的实际执行顺序与我们的预期不符。Java内存模型提供了happens-before规则来帮助我们理解并发操作的有序性。此外，Java还提供了volatile关键字和synchronized关键字来保证有序性。volatile关键字通过禁止指令重排序来保证有序性，而synchronized关键字则通过创建一个临界区来保证同一时刻只有一个线程可以执行临界区内的代码，从而保证了有序性。

那么 volatile 都有哪些作用呢？

"volatile"是一个类型修饰符，用于声明一个变量为"易变的"。当一个变量被声明为"volatile"时，意味着它的值可能会被意外地或并发地改变，因此系统总是会去实际的内存地址取数据，而不是使用保存在某些地方的备份。这可以确保多个线程之间对共享变量的可见性。

volatile 的作用

可见性：当一个共享变量被"volatile"修饰时，它会保证修改的值会立即被更新到主内存，当有其他线程需要读取时，它会去主内存中读取新值。也就是说，一个线程修改了一个"volatile"变量的值，其他线程能够立即看到这个修改。

禁止指令重排序：为了提高程序性能，编译器和处理器可能会对输入代码进行优化：他们可以不按照代码中的顺序执行语句。但是，"volatile"关键字告诉编译器和处理器，不要对标记为"volatile"的变量进行这样的优化。这样可以确保代码的执行顺序与程序员的期望一致。

然而，需要注意的是，"volatile"并不能保证复合操作的原子性。例如，自增操作（i++）实际上包含三个步骤：读取i的值，对值加1，然后将结果写回。即使i是一个"volatile"变量，其他线程仍然可能在这三个步骤之间插入它们的操作，导致结果不符合预期。在这种情况下，通常需要使用锁或其他同步机制来确保原子性。

我们来看看 volatile 保证可见性的示例代码：

public class VolatileVisibilityExample {  
  
    private volatile boolean flag = false;  
  
    public static void main(String[] args) {  
        VolatileVisibilityExample example = new VolatileVisibilityExample();  
  
        // 线程1：负责在一段时间后修改flag的值  
        Thread writerThread = new Thread(() -> {  
            try {  
                Thread.sleep(1000); // 等待1秒  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            example.flag = true; // 修改flag的值  
            System.out.println("Writer thread set flag to true");  
        });  
  
        // 线程2：不断检查flag的值  
        Thread readerThread = new Thread(() -> {  
            while (!example.flag) {  
                // 什么也不做，只是等待flag变为true  
            }  
            System.out.println("Reader thread detected flag is true");  
        });  
  
        // 启动线程  
        readerThread.start();  
        writerThread.start();  
    }  
}

在这个例子中，flag变量被声明为volatile，这意味着当一个线程修改了它的值后，这个修改对其他线程是立即可见的。因此，当writerThread修改了flag为true后，readerThread将能够立即看到这个变化，并退出循环。

如果没有使用volatile关键字，那么由于Java内存模型允许处理器和编译器对指令进行重排序，以及缓存的存在，readerThread可能无法立即看到flag的变化，即使writerThread已经修改了它。这可能导致readerThread无限循环下去，因为它总是读取到的是flag的旧值（缓存中的值）。

通过使用volatile关键字，我们确保了flag变量的可见性，从而避免了这种情况。然而，需要注意的是，volatile并不保证复合操作的原子性，如果涉及更复杂的同步需求，可能需要使用synchronized关键字或其他同步机制。

既然我们刚才说了这个 volatile 还可以禁止指令重排，我们来写个伪代码来看一下：

public class VolatilePreventReorderingExample {  
  
    // 声明一个volatile变量  
    private volatile boolean flag = false;  
  
    private int a = 0;  
    private int b = 0;  
  
    public void writer() {  
        a = 1; // 普通写操作  
        flag = true; // volatile写操作  
    }  
  
    public void reader() {  
        if (flag) { // volatile读操作  
            int b = this.b; // 普通读操作  
            // 这里可能会做一些重要的操作，依赖于b的值  
        }  
    }  
  
    public static void main(String[] args) {  
        VolatilePreventReorderingExample example = new VolatilePreventReorderingExample();  
  
        // 线程1：执行writer方法  
        Thread writerThread = new Thread(() -> {  
            example.writer();  
        });  
  
        // 线程2：执行reader方法  
        Thread readerThread = new Thread(() -> {  
            example.reader();  
        });  
  
        // 启动线程  
        readerThread.start();  
        writerThread.start();  
    }  
}

指令重排是指编译器和处理器为了提高程序性能可能会对指令的执行顺序进行优化调整，但这种调整在并发环境下可能会导致意料之外的结果。

在这个例子中，我们有一个writer方法，它首先将一个普通变量a设置为1，然后将一个volatile变量flag设置为true。在reader方法中，我们首先检查flag变量，如果它是true，则读取另一个普通变量b。

由于flag是volatile的，它会禁止指令重排，确保在writer方法中，对a的写操作不会重排到对flag的写操作之后。这对于reader方法来说是很重要的，因为它依赖于flag的值来确定是否读取b。

如果没有volatile关键字，编译器或处理器可能会选择重排这些指令，例如先设置flag为true，然后再设置a为1。这将导致reader方法可能读取到一个未初始化的b值，即使它看到flag已经是true了。

然而，需要注意的是，尽管volatile可以防止指令重排，但它并不能保证复合操作的原子性。在这个例子中，如果b的赋值和flag的赋值之间存在依赖关系，并且需要在没有其他线程干扰的情况下一起完成，那么可能需要使用额外的同步机制，如synchronized块或Lock接口的实现。

另外，上面的代码示例中并没有显示对b的赋值操作，因此在实际情况下，如果b的值对reader方法是重要的，那么应该在某处正确地初始化它。这个示例主要是为了说明volatile如何防止指令重排，而不是展示一个完全正确的并发程序。

所以，你了解 volatile 关键字了么？