当我们需要在两个线程间依据主内存通信时，通信的那个变量就必须的用 volatile 来修饰：

public class Volatile implements Runnable{

private static volatile boolean flag = true ;

@Override

public void run() {

while (flag){

System.out.println(Thread.currentThread().getName() + "正在运行。。。");

}

System.out.println(Thread.currentThread().getName() +"执行完毕");

}

public static void main(String[] args) throws InterruptedException {

Volatile aVolatile = new Volatile();

new Thread(aVolatile,"thread A").start();

System.out.println("main 线程正在运行") ;

TimeUnit.MILLISECONDS.sleep(100) ;

aVolatile.stopThread();

}

private void stopThread(){

flag = false ;

}

}

主线程在修改了标志位使得线程 A 立即停止，如果没有用 `volatile` 修饰，就有可能出现延迟。

但这里有个误区，这样的使用方式容易给人的感觉是：

这里要重点强调，`volatile` 并**不能**保证线程安全性！

如下程序:

public class VolatileInc implements Runnable{

private static volatile int count = 0 ; //使用 volatile 修饰基本数据内存不能保证原子性

//private static AtomicInteger count = new AtomicInteger() ;

@Override

public void run() {

for (int i=0;i<10000 ;i++){

count ++ ;

//count.incrementAndGet() ;

}

}

public static void main(String[] args) throws InterruptedException {

VolatileInc volatileInc = new VolatileInc() ;

Thread t1 = new Thread(volatileInc,"t1") ;

Thread t2 = new Thread(volatileInc,"t2") ;

t1.start();

//t1.join();

t2.start();

//t2.join();

for (int i=0;i<10000 ;i++){

count ++ ;

//count.incrementAndGet();

}

System.out.println("最终Count="+count);

}

}

当我们三个线程(t1,t2,main)同时对一个 `int` 进行累加时会发现最终的值都会小于 30000。

- 所以想到达到线程安全可以使这三个线程串行执行(那其实就是单线程，没有发挥多线程的优势)。

- 也可以使用 `synchronize` 或者是锁的方式来保证原子性。

- 还可以用 `Atomic` 包中 `AtomicInteger` 来替换 `int`，它利用了 `CAS` 算法来保证了原子性。

内存可见性只是 volatile 的其中一个作用，它还可以防止 JVM 进行指令重排优化。

举一个伪代码:

int a=10 ;//1

int b=20 ;//2

int c= a+b ;//3

一段特别简单的代码，理想情况下它的执行顺序是：`1>2>3`。但有可能经过 JVM 优化之后的执行顺序变为了 `2>1>3`。

可以发现不管 JVM 怎么优化，前提都是保证最终结果不变的情况下进行的。

可能这里还看不出有什么问题，那看下一段伪代码:

private static Map<String,String> value ;

private static volatile boolean flag = fasle ;

public void initMap(){

//耗时操作

value = getMapValue() ;//1

flag = true ;//2

}

public void doSomeThing(){

while(!flag){

sleep() ;

}

//dosomething

doSomeThing(value);

}

这里就能看出问题了，当 `flag` 没有被 `volatile` 修饰时，`JVM` 对 1 和 2 进行重排，导致 value 都还没有被初始化就有可能被线程 B 使用了。

所以加上 `volatile` 之后可以防止这样的重排优化，保证业务的正确性。

一个经典的使用场景就是双重懒加载的单例模式了:

public class Singleton {

private static volatile Singleton singleton;

private Singleton() {

}

public static Singleton getInstance() {

if (singleton == null) {

synchronized (Singleton.class) {

if (singleton == null) {

//防止指令重排

singleton = new Singleton();

}

}

}

return singleton;

}

}

这里的 `volatile` 关键字主要是为了防止指令重排。

如果不用 ，`singleton = new Singleton();`，这段代码其实是分为三步：

- 分配内存空间。(1)

- 初始化对象。(2)

- 将 `singleton` 对象指向分配的内存地址。(3)

加上 `volatile` 是为了让以上的三步操作顺序执行，反之有可能第二步在第三步之前被执行就有可能某个线程拿到的单例对象是还没有初始化的，以致于报错。

`volatile` 在 `Java` 并发中用的很多，比如像 `Atomic` 包中的 `value`、以及 `AbstractQueuedLongSynchronizer` 中的 `state` 都是被定义为 `volatile` 来用于保证内存可见性。

将这块理解透彻对我们编写并发程序时可以提供很大帮助。

package com.crossoverjie.concurrent;

public class Singleton {

private static volatile Singleton singleton;

private Singleton() {

}

public static Singleton getInstance() {

if (singleton == null) {

synchronized (Singleton.class) {

if (singleton == null) {

//防止指令重排

singleton = new Singleton();

}

}

}

return singleton;

}

}

package com.crossoverjie.concurrent;

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileInc implements Runnable{

private static volatile int count = 0 ; //使用 volatile 修饰基本数据内存不能保证原子性

//private static AtomicInteger count = new AtomicInteger() ;

@Override

public void run() {

for (int i=0;i<10000 ;i++){

count ++ ;

//count.incrementAndGet() ;

}

}

public static void main(String[] args) throws InterruptedException {

VolatileInc volatileInc = new VolatileInc() ;

Thread t1 = new Thread(volatileInc,"t1") ;

Thread t2 = new Thread(volatileInc,"t2") ;

t1.start();

//t1.join();

t2.start();

//t2.join();

for (int i=0;i<10000 ;i++){

count ++ ;

//count.incrementAndGet();

}

System.out.println("最终Count="+count);

}

}