下面是一个非常简单的代码，演示了volatile for variable的需求，它用于从其他线程控制线程执行(这是需要volatile的一个场景)。

// Code to prove importance of 'volatile' when state of one thread is being mutated from another thread.
// Try running this class with and without 'volatile' for 'state' property of Task class.
public class VolatileTest {
    public static void main(String[] a) throws Exception {
        Task task = new Task();
        new Thread(task).start();

        Thread.sleep(500);
        long stoppedOn = System.nanoTime();

        task.stop(); // -----> do this to stop the thread

        System.out.println("Stopping on: " + stoppedOn);
    }
}

class Task implements Runnable {
    // Try running with and without 'volatile' here
    private volatile boolean state = true;
    private int i = 0;

    public void stop() {
        state = false;
    } 

    @Override
    public void run() {
        while(state) {
            i++;
        }
        System.out.println(i + "> Stopped on: " + System.nanoTime());
    }
}

当不使用volatile时:即使在“stop on: xxx”之后，你也永远不会看到“Stopped on: xxx”消息，并且程序继续运行。

Stopping on: 1895303906650500

当使用volatile时:你会立即看到'Stopped on: xxx'。

Stopping on: 1895285647980000
324565439> Stopped on: 1895285648087300

演示:https://repl.it/repls/SilverAgonizingObjectcode

每个访问volatile字段的线程在继续之前都会读取它的当前值，而不是(可能)使用缓存的值。

只有成员变量可以是易变的或瞬变的。

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

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

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

假设一个线程修改了一个共享变量的值，如果你没有对该变量使用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缓存中的计数器变量值可能与主存中的不相同。这种情况如下所示:

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