下面是一个非常简单的代码，演示了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

绝对是的。(不仅是Java, c#也是如此。)有时，您需要获取或设置一个值，该值保证是给定平台上的原子操作，例如int或boolean，但不需要线程锁定的开销。volatile关键字允许您确保在读取值时获得的是当前值，而不是在另一个线程上写入时被废弃的缓存值。

Volatile对于停止线程非常有用。

并不是说您应该编写自己的线程，Java 1.6有很多不错的线程池。但是如果你确定你需要一个线程，你需要知道如何停止它。

我使用的线程模式是:

public class Foo extends Thread {

  private volatile boolean close = false;

  public void run() {
    while(!close) {
      // do work
    }
  }
  public void close() {
    close = true;
    // interrupt here if needed
  }
}

在上面的代码段中，while循环中读取close的线程与调用close()的线程不同。如果没有volatile，运行循环的线程可能永远看不到关闭的更改。

注意，这里不需要同步

挥发性

volatile -> synchronized[关于]

Volatile表示对于程序员来说，该值总是最新的。问题是该值可以保存在不同类型的硬件内存中。例如，它可以是CPU寄存器，CPU缓存，RAM…СPU寄存器和CPU缓存属于CPU，不能共享数据，不像RAM在多线程环境中处于抢救状态

volatile关键字表示变量将直接从/写入RAM内存。它有一些计算足迹

Java 5通过支持happens-before扩展volatile[关于]

对volatile字段的写入发生在后续每次读取该字段之前。

Read is after write

volatile关键字不能修复竞态条件[关于]，使用synchronized关键字[关于]

因此，只有当一个线程写入，而其他线程只是读取volatile值时才安全

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

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

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

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

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

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

另一方面，

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

交谈,

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