假设一个线程修改了一个共享变量的值，如果你没有对该变量使用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关键字的两个重要场景是:

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.

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

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

是的，我经常使用它——它对多线程代码非常有用。你指的那篇文章很好。不过有两件重要的事情要记住:

You should only use volatile if you completely understand what it does and how it differs to synchronized. In many situations volatile appears, on the surface, to be a simpler more performant alternative to synchronized, when often a better understanding of volatile would make clear that synchronized is the only option that would work. volatile doesn't actually work in a lot of older JVMs, although synchronized does. I remember seeing a document that referenced the various levels of support in different JVMs but unfortunately I can't find it now. Definitely look into it if you're using Java pre 1.5 or if you don't have control over the JVMs that your program will be running on.

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

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

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

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

另一方面，

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

交谈,

我们不能仅仅使用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关键字解决了可见性问题。