什么是volatile

volatile是Java的一个关键字，用于修饰变量，保证变量的可见性以及有序性。

volatile的使用场景

线程通信（可见性）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class volatileTest {

    volatile boolean flag = true;

    @Test
    public void fun() throws InterruptedException {
        // 3s 后修改 flag = false
        interruptFun();

        while (flag) {
            System.out.println("正在循环");
            Thread.sleep(1000);
        }
    }

    private void interruptFun() {
        new Thread(() -> {
            try {
                Thread.sleep(3000);
                flag = false;
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }).start();
    }
}

限制指令重排（有序性）

拿懒汉式单例模式来举例，volatile不仅可以保证对象不会被重复创建，同时还可以保证其它线程不会获取到一个未初始化的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class volatileTest {

    volatile Object singleton;

    final Object monitor = new Object();

    @Test
    public void fun() throws InterruptedException {
        Object result = getSingleTon();
    }

    private Object getSingleTon() {

        if (singleton == null) {
            synchronized (monitor) {
                if (singleton == null) {
                    singleton = new Object();
                }
            }
        }
        return singleton;
    }
}

volatile原理

可见性

读取之前设置一个读内存屏障

简而言之就是本线程对共享变量的修改对其它线程是可见的，强制线程每次读本地变量都需要从主存同步最新值，每次修改完之后都需要同步到主存，同时通知其它线程把本地变量置为无效状态。

volatile通过JVM指令实现可见性，JVM的指令最终会依赖OS的指令

JVM层面

通过内存屏障实现，读屏障会记录哪些线程读取了这个变量，当写线程修改了这个变量，会触发写屏障，会通知读屏障记录的这些读线程再次读取最新值

OS层面

通过缓存一致性协议（如MESI协议），每个CPU嗅探总线的变量修改，当变量被修改，会将自己高速缓存的值设置为无效，如果需要修改，则要去主存读取最新值

有序性

简而言之就是线程的某个语句不会被重排优化（编译器或者处理器优化）而导致最后程序的语义不同，通过内存屏障来解决这个问题，有4种内存屏障：

  • StoreStore：在volatile写之前，保证之前的普通写不会重排到volatile写之后
  • StoreLoad：在volatile写之后，保证之后的volatile读/写不会重排volatile写之前
  • LoadStore：在volatile读之后，保证之后的普通读不会重排到volatile读之前
  • LoadStore：在volatile读之后，保证之后的普通写不会重排到volatile读之前

对于x86处理器，只会重排写-读，不会重排读-读、写-写，所以只需要使用StoreLoad屏障就可以保证有序性。

拿上述的单例模式来说，保证了对volatile的singleton的读取在volatile写之后，就可以保证对象是完全创建好的。