Java volatile关键字及双重锁单例详解

た入场券 2023-01-05 14:26 139阅读 0赞

synchronized相信大家都应该不陌生吧，这个关键词一般出现在单例模式里面比较常见，在叙说这篇文章之前，我们先看看什么是内存模型概念，这对后续的理解有很大的帮助。

***内存模型概念***  
计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。简单的说就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。

就打个比方，执行一条语句i = i + 1，首先会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中，这条语句在单线程中运行是没有啥问题的，但是如果运行在多线程上面，就会有问题了，假如i = 0，有两个线程同时执行这条语句，线程A先把i的值复制到高速缓存中，然后CPU对指令进行执行操作，也就是把i进行+1，此时i的结果是1，然而在这个时候，线程A还没有把i的值刷新在主存上，线程B就对这条语句进行执行，此时的i还是等于0的，所以线程B执行完之后i的值是1，然后线程A在把i的值刷新到主存，得到的最后结果是1，并不是我们预想中的2，这就导致了缓存不一致性问题，先圆规正传，聊聊volatile的特性。

***- 可见性***  
1、对一个volatile变量的读总是能看到任意线程对这个变量最后的写，即每次读取volatile变量的时候，会使线程工作内存中的变量副本无效，从而必须从主内存中更新变量值。  
2、对一个volatile变量进行写操作后，会立刻将修改的值同步到主内存，以便于后面读取该变量的线程获取到的是最新的值，这就是volatile的可见性，可以用来解决上面所述说的缓存不一致问题。

***- 禁止指令重排序***  
什么是指令重排？  
指令重排序是指JVM在编译Java文件或者CPU在处理JVM字节码的时候，对现有的指令进行重新排序，但是这个重新排序并不会影响到最后的结果，只是优化程序的运行效率。  
例如下面这段代码：

public void mySort() {
        
    	int x = 11;
    	int y = 12;
    	x = x + 5;
    	y = x * x;
    }

正常执行顺序的1234，但是如果在多线程的环境下可能会出现多种情况，比如2134之类的，但是不会出现4123这种情况，因为处理器在进行重排时候，必须考虑到指令之间的数据依赖性。

再比如下面这段代码：

public class ResortSeqDemo {
        
        int a= 0;
        boolean flag = false;
    
        public void method1() {
        
            a = 1;
            flag = true;
        }
    
        public void method2() {
        
            if(flag) {
        
                a = a + 5;
                System.out.println("reValue:" + a);
            }
        }
    }

正常的执行是先调用method1，然后在调用method2，最后的输出结果a=6，但是如果运行在多线程的环境下，引文method1中的a和flag并没有依赖性，可能执行完 flag = true;之后会调用method2，然后在调用a=1，这就导致最后的输出的结果是5，因此导致最后的运算结果出错，结果无法确定，这样就需要通过volatile来修饰，来保证线程安全性。

Volatile实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象，主要涉及到的原理技术是内存屏障，也称为内存栅栏，是一种屏障指令，它使CPU或编译器对屏障指令之前和之后发出的内存操作执行一个排序约束，使其不会被重新排序。

在一个变量被volatile修饰后，JVM会为我们做两件事：  
1.在每个volatile写操作前插入StoreStore屏障，在写操作后插入StoreLoad屏障。  
2.在每个volatile读操作前插入LoadLoad屏障，在读操作后插入LoadStore屏障。  
这就可以使我们的程序得到预料中的结果，而不会因为多线程的问题导致程序运算出错；

*  原子性  
    对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。  
    看看如下几条语句：

x = 10;         //语句1
    y = x;         //语句2
    x++;           //语句3
    x = x + 1;     //语句4

这四条语句中只有语句1是具有原子性的  
语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中。  
语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及 将x的值写入工作内存 这2个操作都是原子性操作，但是合起来就不是原子性操作了。同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。  
也就是说，只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

双重锁单例模式

public class Singleton {
        
        private Singleton() {
        
        }
    
        private volatile static Singleton instance;
    
        public static synchronized Singleton getInstance() {
        
             //第一重
            if (instance == null) {
        
                synchronized (Singleton.class) {
        
                    //第二重
                    if (instance == null) {
        
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }

1、如果单例已经创建了，直接调用synchronized加锁比较耗性能。所以首先判断有没有创建，没创建再加锁。  
2、第二层非空检查的原因是在同时多个线程调用时，A线程获得锁并创建成功实例，之后释放锁，前面一起竞争的B线程获得锁，首先判断非空，代表已经创建了，所以不会继续去创建实例。