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

使用volatile的一个常见示例是使用volatile布尔变量作为终止线程的标志。如果您已经启动了一个线程，并且希望能够安全地从另一个线程中断它，您可以让线程定期检查标志。要阻止它，将标志设置为true。通过将标志设置为易失性，可以确保正在检查它的线程在下次检查时看到它已经设置好，甚至不必使用同步块。

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

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的变量，读和写都是原子的 (包括长变量和双变量)。

干杯!

在我看来，除了停止线程之外，使用volatile关键字的两个重要场景是:

Double-checked locking mechanism. Used often in Singleton design pattern. In this the singleton object needs to be declared volatile. Spurious Wakeups. Thread may sometimes wake up from wait call even if no notify call has been issued. This behavior is called spurious wakeup. This can be countered by using a conditional variable (boolean flag). Put the wait() call in a while loop as long as the flag is true. So if thread wakes up from wait call due to any reasons other than Notify/NotifyAll then it encounters flag is still true and hence calls wait again. Prior to calling notify set this flag to true. In this case the boolean flag is declared as volatile.

虽然我在这里提到的答案中看到了许多很好的理论解释，但我在这里添加了一个实际的例子来解释:

1.

代码在不使用volatile的情况下运行

public class VisibilityDemonstration {

private static int sCount = 0;

public static void main(String[] args) {
    new Consumer().start();
    try {
        Thread.sleep(100);
    } catch (InterruptedException e) {
        return;
    }
    new Producer().start();
}

static class Consumer extends Thread {
    @Override
    public void run() {
        int localValue = -1;
        while (true) {
            if (localValue != sCount) {
                System.out.println("Consumer: detected count change " + sCount);
                localValue = sCount;
            }
            if (sCount >= 5) {
                break;
            }
        }
        System.out.println("Consumer: terminating");
    }
}

static class Producer extends Thread {
    @Override
    public void run() {
        while (sCount < 5) {
            int localValue = sCount;
            localValue++;
            System.out.println("Producer: incrementing count to " + localValue);
            sCount = localValue;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                return;
            }
        }
        System.out.println("Producer: terminating");
    }
}
}

在上面的代码中，有两个线程——生产者和消费者。

生产者线程在循环中迭代5次(睡眠时间为1000毫秒或1秒)。在每次迭代中，生产者线程将sCount变量的值增加1。因此，在所有迭代中，生产者将sCount的值从0更改为5

使用者线程处于一个常量循环中，每当sCount的值发生变化时，它就会打印，直到值达到5为止。

两个循环同时开始。因此，生产者和消费者都应该将sCount的值打印5次。

输出

Consumer: detected count change 0
Producer: incrementing count to 1
Producer: incrementing count to 2
Producer: incrementing count to 3
Producer: incrementing count to 4
Producer: incrementing count to 5
Producer: terminating

分析

In the above program, when the producer thread updates the value of sCount, it does update the value of the variable in the main memory(memory from where every thread is going to initially read the value of variable). But the consumer thread reads the value of sCount only the first time from this main memory and then caches the value of that variable inside its own memory. So, even if the value of original sCount in main memory has been updated by the producer thread, the consumer thread is reading from its cached value which is not updated. This is called VISIBILITY PROBLEM .

2.

代码使用volatile运行

在上面的代码中，用下面的代码替换声明了sCount的代码行:

private volatile  static int sCount = 0;

输出

Consumer: detected count change 0
Producer: incrementing count to 1
Consumer: detected count change 1
Producer: incrementing count to 2
Consumer: detected count change 2
Producer: incrementing count to 3
Consumer: detected count change 3
Producer: incrementing count to 4
Consumer: detected count change 4
Producer: incrementing count to 5
Consumer: detected count change 5
Consumer: terminating
Producer: terminating

分析

当我们声明一个变量为volatile时，这意味着所有对这个变量的读写操作都将直接进入主存。这些变量的值永远不会被缓存。

由于sCount变量的值永远不会被任何线程缓存，消费者总是从主内存中读取sCount的原始值(在那里由生产者线程更新)。因此，在这种情况下，输出是正确的，两个线程都打印了5次不同的sCount值。

通过这种方式，volatile关键字解决了可见性问题。