（二）volatile 学习

朱雀 2020-10-25 07:30 729阅读 0赞

> volatile是java虚拟机提供的轻量级的同步机制

## 1.特性 ##

> 1.  保证可见性
> 2.  不保证原子性
> 3.  禁止指令重排

## 2. 特性解释 ##

### 2.1 可见性： ###

一个线程操作某个对象，修改了值之后，其余的线程都知道，这就叫可见性

> 各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后再写回到主内存中的。
> 
> 这就可能存在一个线程AAA修改了共享变量X的值，但还未写回主内存时，另外一个线程BBB又对主内存中同一个变量X进行操作，但此时A线程工作内存中共享变量X对线程B来说并不可见
> 
> 这种工作内存与主内存同步延迟现象就造成了可见性问题

/**
    * 1验证volatile的可见性
    * 1.1 如果int num = 0，number变量没有添加volatile关键字修饰
    * 1.2 添加了volatile，可以解决可见性
    */
    public class VolatileDemo {
    
      public static void main(String[] args) {
          visibilityByVolatile();//验证volatile的可见性
      }
    
      /**
       * volatile可以保证可见性，及时通知其他线程，主物理内存的值已经被修改
       */
      public static void visibilityByVolatile() {
          MyData myData = new MyData();
    
          //第一个线程
          new Thread(() -> {
              System.out.println(Thread.currentThread().getName() + "\t come in");
              try {
                  //线程暂停3s
                  TimeUnit.SECONDS.sleep(3);
                  myData.addToSixty();
                  System.out.println(Thread.currentThread().getName() + "\t update value:" + myData.num);
              } catch (Exception e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
              }
          }, "thread1").start();
          //第二个线程是main线程
          while (myData.num == 0) {
              //如果myData的num一直为零，main线程一直在这里循环
          }
          System.out.println(Thread.currentThread().getName() + "\t mission is over, num value is " + myData.num);
      }
    }
    
    class MyData {
      //    int num = 0;
      volatile int num = 0;
    
      public void addToSixty() {
          this.num = 60;
      }
    }

输出结果：

thread1   come in
    thread1   update value:60
    // 线程没有检测到值的变化进入死循环

当我们加上`volatile`关键字后，`volatile int num = 0;`输出结果为：

thread1   come in
    thread1   update value:60
    main  mission is over, num value is 60
    //程序没有死循环，结束执行

### 2.2 原子性： ###

> 一个线程在操作某个对象时，对象的值发生更改，并更新回主内存，其余线程还未获得更新的消息，将值同样更新回主内存，造成数据丢失的情况，即不保证原子性

class MyData {
            /**
             * 增强了各线程的可见性
             */
            volatile int number = 0;
        
            public void addTo60() {
                this.number = 60;
            }
        
            /**
             * 请注意，此时 number 前面是加了volatile关键字修饰的，volatile不保证原子性
             */
            public void addPlusPlus() {
                // number++ 在多线程下是非线程安全的，如何不加synchronized解决？
                number++;
            }
        
            AtomicInteger atomicInteger = new AtomicInteger();
        
            public void addMyAtomic() {
                atomicInteger.getAndIncrement();
            }
        }
        
        /**
         * 1、验证 volatile 的可见性
         * 1.1 加入 int number =0 ，number变量之前根本没有添加 volatile 关键字修饰
         * 1.2 添加了volatile ，可以解决可见性问题
         * <p>
         * 2、验证volatile不保证原子性
         * 2.1 原子性指的是什么意思：
         * 不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割。需要整体完整
         * 要么同时成功，要么同时失败。
         * 2.2 volatile 不保证原子性的演示案例
         * 2.3 why
         * 2.4 如何解决原子性
         * * 加 synchronized
         * * 使用我们 JUC 下的AtomicInteger
         */
        public class VolatileDemo {
            public static void main(String[] args) {
                MyData myData = new MyData();
                for (int i = 0; i < 20; i++) {
                    new Thread(() -> {
                        for (int j = 0; j < 1000; j++) {
                            myData.addPlusPlus();
                            myData.addMyAtomic();
                        }
                    }, String.valueOf(i)).start();
                }
                // 需要等待上卖弄20个线程都全部计算完成后，在用main线程去得最终的结果值，看是多少？
                while (Thread.activeCount() > 2) {
                    // 礼让线程
                    Thread.yield();
                }
                Map<String, String> s = new HashMap<>();
                System.out.println(Thread.currentThread().getName() + "\t int type, finally number value : " + myData.number);
                System.out.println(Thread.currentThread().getName() + "\t atomicInteger, finally number value : " + myData.atomicInteger);
            }

执行结果

main     int type, finally number value : 15940
        main     atomicInteger, finally number value : 20000

### 2.3 禁止指令重排 ###

计算机执行程序时，为了提高性能，编译器和处理器常常会对 `指令做重排`,一般分以下三种

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

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

> 了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，他的作用有两个：
> 
>  *  一是保证特定操作的执行顺序
>  *  而是保证某些变量的内存可见性（利用该特性，实现volatile的内存可见性）
> 
> 由于编译器和处理器都能执行指令重排优化，如果在指令间插入一条**Memory Barrier**，则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier 指令重排序，也就是说 `通过插入内存屏障，禁止在内存屏障前后的指令执行重排序优化`。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

## 3、volatile 在单例模式下的应用 ##

### 3.1 普通单例模式在多线程下的结果 ###

public class SingletonDemo {
        private static SingletonDemo instance = null;
    
        private SingletonDemo() {
            System.out.println(Thread.currentThread().getName() + "\t 构造方法SingletonDemo（）");
        }
    
        public static SingletonDemo getInstance() {
            if (instance == null) {
                instance = new SingletonDemo();
            }
            return instance;
        }
    
        public static void main(String[] args) {
            //构造方法只会被执行一次
    //        System.out.println(getInstance() == getInstance());
    //        System.out.println(getInstance() == getInstance());
    //        System.out.println(getInstance() == getInstance());
    
            //并发多线程后，构造方法会在一些情况下执行多次
            for (int i = 0; i < 10; i++) {
                new Thread(() -> {
                    SingletonDemo.getInstance();
                }, "Thread " + i).start();
            }
        }
    }

### 3.2 解决方法 ###

*  加入单例模式 DCL（Double Check Lock双端检锁机制） 代码  
    DCL （Double Check Lock双端检锁机制）在加锁前和加锁后都进行一次判断
    
        public static SingletonDemo getInstance() {
              if (instance == null) {
                  synchronized (SingletonDemo.class) {
                      if (instance == null) {
                          instance = new SingletonDemo();
                      }
                  }
              }
              return instance;
          }
    
    **大部分运行结果构造方法只会被执行一次**，但指令重排机制会让程序很小的几率出现构造方法被执行多次，**DCL（双端检锁）机制不一定线程安全**，原因时有指令重排的存在，加入volatile可以禁止指令重排
    
    > 原因是在某一个线程执行到第一次检测，读取到instance不为null时，instance的引用对象可能`没有完成初始化`。instance=new SingleDemo();可以被分为一下三步（伪代码）：
    > 
    >     memory = allocate();//1.分配对象内存空间
    >     instance(memory);   //2.初始化对象
    >     instance = memory;  //3.设置instance执行刚分配的内存地址，此时instance!=null
    > 
    > 步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排优化时允许的，**如果3步骤提前于步骤2，但是instance还没有初始化完成**，指令重排只会保证串行语义的执行的一致性（单线程），但并不关心多线程间的语义一致性。**所以当一条线程访问instance不为null时，由于instance示例未必已初始化完成，也就造成了线程安全问题。**
 *  加上 volatile 禁止指令重排
    
        private static volatile SingletonDemo instance = null;