The volatile key when used with a variable, will make sure that threads reading this variable will see the same value . Now if you have multiple threads reading and writing to a variable, making the variable volatile will not be enough and data will be corrupted . Image threads have read the same value but each one has done some chages (say incremented a counter) , when writing back to the memory, data integrity is violated . That is why it is necessary to make the varible synchronized (diffrent ways are possible)

如果修改是由一个线程完成的，而其他线程只需要读取这个值，则volatile将是合适的。

是的，当你想要一个可变变量被多个线程访问时，必须使用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关键字解决了可见性问题。

如果您正在开发多线程应用程序，您将需要使用'volatile'关键字或'synchronized'以及您可能拥有的任何其他并发控制工具和技术。桌面应用就是这样一个例子。

If you are developing an application that would be deployed to application server (Tomcat, JBoss AS, Glassfish, etc) you don't have to handle concurrency control yourself as it already addressed by the application server. In fact, if I remembered correctly the Java EE standard prohibit any concurrency control in servlets and EJBs, since it is part of the 'infrastructure' layer which you supposed to be freed from handling it. You only do concurrency control in such app if you're implementing singleton objects. This even already addressed if you knit your components using frameworkd like Spring.

因此，在Java开发的大多数情况下，应用程序是一个web应用程序，并使用IoC框架，如Spring或EJB，你不需要使用'volatile'。

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