Java并发编程之 volatile原理

矫情吗；* 2022-10-23 01:56 243阅读 0赞

# Java并发编程之 volatile原理 #

### 文章目录 ###

*  Java并发编程之 volatile原理
 *   *  一、Java内存模型
     *  二、JMM特点
     *   *  1. 可见性
         *   *  (1) 不可见的情况
             *  (2) 出现的原因
             *  (3) 解决方法
             *  (4) 可见性 vs 原子性
         *  2. 有序性
     *  三、volatile原理
     *   *  1. 如何保证可见性
         *  2. 如何保证有序性
         *  3. 注意

## 一、Java内存模型 ##

Java 内存模型即 JMM，它从java层面定义了主存（所有线程都共享的数据，比如成员变量等）、工作内存（指的是线程私有的数据，比如局部变量等）

JMM 体现在以下几个方面：

1.  原子性 \- 保证指令不会受到线程切换的影响，比如 synchronized 中的代码块，即使执行过程中线程发生了切换，也可以保证其中的代码不会受到影响（加了锁）
2.  可见性 \- 保证指令不会受 cpu 缓存的影响，不可见指的是一个线程对主存的数据进行了修改，对另一个线程是不可见的，依然使用的是修改之前的数据
3.  有序性 \- 保证指令不会受 cpu 并行优化的影响

## 二、JMM特点 ##

### 1. 可见性 ###

#### (1) 不可见的情况 ####

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止

public class Test1 { 
        static boolean run = true; //主存数据
        public static void main(String[] args) throws InterruptedException { 
            Thread t = new Thread(()->{ 
                while(run){ 
                    //todo
                }
            });
            
            t.start();
            
            Thread.sleep(1000);  
            run = false; // 线程t不会如预想的停下来
        }
    }

#### (2) 出现的原因 ####

1.  初始状态， t 线程从主内存读取 run 的值到自己的工作内存
    
    ![20210318093559606.png][]
2.  因为t1线程频繁的从主存中读取run的值，JIT编译器认为总是去主存中读取效率比较低，会将run的值缓存到线程t的工作内存中的高速缓存中，减少对主存中run的访问以提高效率
    
    ![20210318093608471.png][]
3.  1 秒之后，main 线程修改了 run 的值，并同步至主存，但 t 线程是从自己的工作内存中的高速缓存中读取这个变量的值，结果永远是旧值
    
    ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70][]

#### (3) 解决方法 ####

volatile（表示易变关键字的意思），可以用来修饰主存的数据，它可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值（一定程度上会影响效率）

对于上述出现不可见情况的代码，将主存的数据修改为 `volatile static boolean run = true;` t 线程会如预期停止下来

**使用synchronized关键字**也可以保证可见性，如下：

在Java内存模型中，synchronized规定，线程在加锁时， 先清空工作内存→在主内存中拷贝最新变量的副本到工作内存 →执行完代码→将更改后的共享变量的值刷新到主内存中→释放互斥锁。但推荐使用volatile，比较轻量

@Slf4j(topic = "c.Test32")
    public class Test32 { 
        static boolean run = true; //主存数据
    
        final static Object lock = new Object(); //锁对象
    
        public static void main(String[] args) throws InterruptedException { 
            Thread t = new Thread(()->{ 
                while(true){ 
                    synchronized (lock){ 
                        if(!run) { 
                            break;
                        }
                    }
                }
            });
            t.start();
    
            Thread.sleep(1000);
            synchronized (lock) { 
                run = false; // 线程t会停下来
            }
        }
    }

#### (4) 可见性 vs 原子性 ####

*  volatile 关键字保证可见性， 而不能保证原子性
 *  synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性；但缺点是  
    synchronized 是属于重量级操作，性能相对更低

### 2. 有序性 ###

*  JVM在不影响正确性的前提下，可以调整语句的执行顺序（指令重排）
 *  指令的各个阶段可以通过重排序和组合实现指令级并行
    
     *  打个比方
        
         *  没有使用指令重排
            
            ![20210318093637866.png][]
         *  使用了指令重排
            
            ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 1][]
            
            效率得到了提升，增加了并发性
 *  指令重排也需要遵守一定规则
    
     *  重排序操作不会对存在数据依赖关系的操作进行重排序
        
         *  比如：`a=1;b=a;`这个指令序列，由于第二个操作依赖于第一个操作，所以在编译时和处理器运行时这两个操作不会被重排序
     *  重排序是为了优化性能，但是不管怎么重排序，单线程下程序的执行结果不能被改变
        
         *  比如：`a=1;b=2;c=a+b` 这三个操作，第一步（a=1) 和第二步 (b=2) 由于不存在数据依赖关系，所以可能会发生重排序，但是c=a+b这个操作是不会被重排序的，因为需要保证最终的结果一定是c=a+b
 *  重排序在单线程模式下是一定会保证最终结果的正确性，但是在多线程环境下，会出现线程不安全的问题
 *  volatile 修饰的变量，可以禁用指令重排
 *  使用synchronized并不能解决有序性问题，但是如果是该变量整个都在synchronized代码块的保护范围内，那么变量就不会被多个线程同时操作，也不用考虑有序性问题，在这种情况下相当于解决了重排序问题

## 三、volatile原理 ##

*  volatile 的底层实现原理是内存屏障 Memory Barrier（Memory Fence）
    
     *  对 volatile 变量的写操作后会加入写屏障
     *  对 volatile 变量的读操作前会加入读屏障

### 1. 如何保证可见性 ###

*  写屏障保证在该屏障之前对共享变量的改动，都同步到主存当中
    
        public void actor2(I_Result r) { 
             num = 2; //普通变量
             ready = true; // ready是被volatile修饰的 ，赋值操作即写操作
             // 写屏障
             // 对num及ready的变动，都会同步到主存当中
        }
 *  读屏障保证在该屏障之后对共享变量的读取，加载的是主存中最新数据

public void actor1(I_Result r) { 
     // 读屏障
     // ready是被volatile修饰的，读操作
     if(ready) { 
     	r.r1 = num + num;
     } else { 
     	r.r1 = 1;
     }
      // ready、num读取的都是主存中的
    }

### 2. 如何保证有序性 ###

*  写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
 *  读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

### 3. 注意 ###

*  volatile可保证可见性和有序性，无法保证原子性，而synchronized三者都可以保证

[20210318093559606.png]: /images/20221022/e469ed04a9cb4eedaf8b856ae0ebc7d2.png
[20210318093608471.png]: /images/20221022/501decc399dc4340bd59d2b72fb5e5f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70]: /images/20221022/d1b03cbfd31f4c71a49e205aa207b062.png
[20210318093637866.png]: /images/20221022/d0be51c166de4412897780c92f81344d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80OTM0MzE5MA_size_16_color_FFFFFF_t_70 1]: /images/20221022/545d4f79dbc34fd8a5022b6462a1ea97.png