我理解的Volatile三大特性概念详解

---

前言

对volatile概念学习，予以记录！

学习三板斧：理论，代码，小总结

参考博客：
Java中的包装类缓存
Java多线程优化都不会，怎么拿Offer?
volatile为什么不能保证原子性
volatile实现禁止指令重排底层操作原理

一、基础知识储备

1、Java内存模型是什么？

JMM（Java内存模型Java Memory Model）本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

JMM关于同步的规定：

1. 线程解锁前，必须把共享变量的值刷新回主内存
2. 线程加锁前，必须读取主内存的最新值到自己的工作内存
3. 加锁解锁是同一把锁

JMM内存模型之可见性

可见性指当一个线程修改了某一个共享变量的值，其他的线程是否能够立即知道这个修改。显然，对于串行程序来说，可见性问题是不存在的。因为我们在任何一个操作步骤中修改了某个变量，那么在后续的步骤中，读取这个变量一定是修改后的值。

JMM内存模型之原子性

原子性指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或分割，需要整体完整，要么同时成功，要么同时失败

单个基本数据类型的基本运算可以看作是保证原子性的，但多个基本数据类型运算不能保证。比如：

int j=1;//可保证

int z=j;//不能保证

z++;//不能保证
1
2
3
4
5

当多个线程对同一使用volatile定义的共享变量进行num++时，被分为以下几个步骤：

1. 线程读取num
2. temp = num + 1
3. num = temp

首先线程a，b读取到num=0，

线程a开始执行temp=num+1,线程b开始执行temp=num+1,此时线程a,b的私有工作内存中num=0,temp=1,

此时a执行num=temp,由于MESI缓存一致性与cpu总线嗅探机制（监控机制）,

此时num的值会立即刷新到主存并通知其他线程保存的 num 值失效,

此时B线程需要重新读取 num 的值那么此时B线程保存的 num 就是1，

同时B线程保存的 temp 还仍然是1， 然后B线程执行 num=temp ，所以导致了计算结果比预期少了1
1
2
3
4
5
6
7
8
9
10
11

JMM内存模型之有序性

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排

源代码——>编译器优化的重排——>指令并行的重排——>内存系统的重排——>最终执行的指令

有序性指对于一个线程的执行代码，我们习惯性的认为代码的执行是从前往后，依次执行的。但是在并发时，程序的执行可能会出现乱序。给人直观的感觉就是：写在前面的代码，可能会在后面执行。一般分为以下3种：

1. 单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致
2. 处理器在进行重排序时必须要考虑指令之间的数据依赖性
3. 多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测

2、内存屏障是什么？（概念）

内存屏障（memory barrier）是一个CPU指令

基本上，它是这样一条指令： 

a) 确保一些特定操作执行的顺序；
b) 影响一些数据的可见性(可能是某些指令执行后的结果)。

以上也就是volatile保证可见性与禁止指令重排序的方法
1
2
3
4
5
6

其次理解一下 内存屏障的基本使用（概念）：

编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。

插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。
内存屏障另一个作用是强制更新一次不同CPU的缓存。
例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，
这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个CPU核心或者哪颗CPU执行的。

内存屏障（memory barrier）和volatile什么关系？
如果你的字段是volatile，Java内存模型将在写操作后插入一个写屏障指令，在读操作前插入一个读屏障指令。

这意味着如果你对一个volatile字段进行写操作，
你必须知道：

1.一旦你完成写入，任何访问这个字段的线程将会得到最新的值。
2.在你写入前，会保证所有之前发生的事已经发生，并且任何更新过的数据值也是可见的，

因为内存屏障会把之前的写入值都刷新到缓存。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3、了解线程从主内存修改数据需要进行的步骤（概念）

- read：从主内存中读取数据

- load：加载到某个线程中的私有工作内存中

- use：使用某个或某些数据

- assign：对某个或某些数据进行赋值运算

- store：将结果存储在私有工作内存中

- write：将结果写入主内存中

且线程之间无法直接传入变量
1
2
3
4
5
6
7
8
9
10
11
12
13

---

二、volatile是java提供的一种轻量级的同步机制

synchronized保证可见性、保证原子性、禁止指令重排序，但不保证并发性

volatile是一种轻量级的synchronized，在保证可见性、不保证原子性、禁止指令重排序的前提下，兼顾并发性

三、volatile三大特性：保证可见性、不保证原子性、禁止指令重排序

1、保证可见性

JMM内存模型之可见性：即当线程完成对于共享变量的操作并写回主内存后，主内存在第一时间通知其他相关线程共享变量发生变化的机制

早期：对共享变量加一把总线锁

现在：MESI缓存一致性协议，CPU总线嗅探机制（监听机制）

①如果线程内的共享变量发生改变，则当前处理器的缓存立即同步到主内存，缓存行锁定
②触发MESI缓存一致性，线程工作内存共享变量失效

首先理解一个概念读写冲突：

当线程 A 获取读锁时，
如果线程 B 正在执行写操作，线程 A 需要等待，否则会引起 read-write conflict（读写冲突）。

如果线程 B 正在执行读操作，线程 A 不需要等待，因为 read-read 不会引起 conflict（冲突）。

当线程 A 要获取写入锁时，
如果线程 B 正在执行写操作，线程 A 需要等待，否则会引起 write-write conflict（写写冲突）。

如果线程 B 正在执行读操作，则线程 A 需要等待，否则会引起 read-write conflict（读写冲突）。
1
2
3
4
5
6
7
8
9

测试代码：

//实体类，观察num值的可见性，此时没有volatile
class Volatile{
    int num=0;

    public void addTo60(){
        this.num=60;
    }
}
//测试类
public class MyClass {
	
    public static void main(String[] args) {
        seeVolatileOk();//测试可见性
    }
    //aaa线程修改num值为60后，main线程拿到的num=0，死循环。说明线程之间共享变量不可见。
    private static void seeVolatileOk() {
        Volatile v = new Volatile();
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t come in ");;
            try {
            	// 暂停aaa线程2秒钟
                TimeUnit.SECONDS.sleep(2);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            v.addTo60();
            System.out.println(Thread.currentThread().getName()+"\t updated num value:"+v.num);

        },"aaa").start();

        while (v.num==0){
        	// main线程就一直在这里等待循环，直到number值不再等于0
        }
        System.out.println(Thread.currentThread().getName()+"\t mission is over,updated num value:"+v.num);
    }
}
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
27
28
29
30
31
32
33
34
35
36
37

结果：

实例变量num未定义为volatile，程序仍在运行，main线程无法得知num已经发生变化：

实例变量num定义为volatile:

TIPS：那么说明了volatile可以保证线程间的可见性

2、不保证原子性

JMM内存模型之原子性：不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或分割，需要整体完整，要么同时成功，要么同时失败。

单个基本数据类型的基本运算可以看作是保证原子性的，但多个基本数据类型运算不能保证。比如：

int j=1;//可保证

int z=j;//不能保证

z++;//不能保证
1
2
3
4
5

当多个线程对同一使用volatile定义的共享变量进行num++时，被分为几个步骤。

执行num++需要进行以下步骤：

1、线程读取num		2、temp = num + 1 		3、num = temp

首先线程a，b读取到num=0，

线程a开始执行temp=num+1,线程b开始执行temp=num+1,此时线程a,b的私有工作内存中num=0,temp=1,

此时a执行num=temp,由于MESI缓存一致性与cpu总线嗅探机制（监控机制）,

此时num的值会立即刷新到主存并通知其他线程保存的 num 值失效,

此时B线程需要重新读取 num 的值那么此时B线程保存的 num 就是1，

同时B线程保存的 temp 还仍然是1， 然后B线程执行 num=temp ，所以导致了计算结果比预期少了1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

测试代码：

// 注意此时已加上volatile ! ! !
class Volatile{
    volatile int num=0;
    public void addPlusPlus(){
        this.num++;// num++ 不保证原子性
    }
}

public class MyClass {
    public static void main(String[] args) {
        atomicIntegerOk();// 测试原子性
    }
    // 20000个线程执行num++，按习惯来说num=20000，然而······
    private static void atomicIntegerOk() {
        Volatile v = new Volatile();
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 1000; j++) {
                new Thread(()->{
                    v.addPlusPlus();
                    },String.valueOf(i)).start();
            }
        }
		// 后台默认两个线程，main线程与后台GC线程
        while (Thread.activeCount()>2){
        	// 礼让线程，让其他线程执行
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t updated int num value:"+v.num);
        System.out.println(3*0.1==0.3);//false精度问题
        System.out.println(new Integer(30).equals(new Integer(30)));//相等，包装类型缓存
    }
}
    
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
27
28
29
30
31
32
33

结果：

多执行几次：


数值结果丢失的原因，出现了写覆盖：

解决方法：

1.在方法体中加上synchronized，不推荐性能损耗太大

2.利用java.util.concurrent.atomic.AtomicInteger类

上代码：

class Volatile{
    volatile int num=0;

    public void addPlusPlus(){
        this.num++;
    }
    AtomicInteger atomicInteger=new AtomicInteger();
    public void addMyTomic(){
        atomicInteger.getAndIncrement();//调用自增1方法
    }
}

public class MyClass {
    public static void main(String[] args) {
//        seeVolatileOk();
        atomicIntegerOk();
    }
    private static void atomicIntegerOk() {
        Volatile v = new Volatile();
        for (int i = 0; i < 20; i++) {
            for (int j = 0; j < 1000; j++) {
                new Thread(()->{
                    v.addPlusPlus();
                    v.addMyTomic();
                    },String.valueOf(i)).start();
            }
        }
        while (Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t updated int num value:"+v.num);
        System.out.println(Thread.currentThread().getName()+"\t updated Atomic Integer num value:"+v.atomicInteger);
    }
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
27
28
29
30
31
32
33

结果（对比）：

多执行几次：

执行了五六遍，总算有等于的结果了

TIPS：说明了volatile不保证原子性，且用volatile修饰的变量num执行自增后结果应该是<=20000 注意这个等号！

那为什么AtomicInteger类能够保证原子性？unSafe类，自旋锁

对于代码中最后一个问题，可以参考 Java中的包装类缓存，好文要强推！

3、禁止指令重排序

JMM内存模型之有序性：计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下3种：

源代码——>编译器优化的重排——>指令并行的重排——>内存系统的重排——>最终执行的指令

1. 单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致
2. 处理器在进行重排序时必须要考虑指令之间的数据依赖性
3. 多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测

小总结：