volatile

作用

• 内存可见性

  public class VolatileTest {
      //(1)定义一个变量a
      int a = 0;
      void test() {
          System.out.println("a=" + a + " start");
          //(2)如何a=0就一直循环
          while (a == 0) {
          }
          System.out.println("a=" + a + " end");
      }
  
      public static void main(String[] args) {
          VolatileTest t = new VolatileTest();
          //(3)创建一个线程执行test方法
          Thread thread1 = new Thread(() ->{
              t.test();
          });
          thread1.start();
        
          try {
              TimeUnit.SECONDS.sleep(1);
          } catch (Exception ex) {
              ex.printStackTrace();
          }
        
          //(4)休眠一秒后修改a的值为1
          t.a = 1;
            //(5)输出a的值
            System.out.println("a=" + t.a);
      }
  
  }
  

  此程序

  (1)中定义了一个变量a,赋值为0;

  (2)中定义了一个test方法,方法体内有一个while循环，判断a的值是否为0，如果为0，就一直空循环；

  (3)的main方法创建了一个线程，线程去执行test方法；

  (4)在主线程休眠1秒后将a的值改为1；

  (5)输出a的最新值

  当控制台输出了a=1时，表示a的值已经被修改为了1，所以正常来说程序应该输出“a=1 end”结束，但是实际情况并没有。

• 原因：
  1、在main方法中新开启的线程thread1，thread1读取主内存中的a=0到自己的工作内存中；
  2、然后main线程从主内存中获取a的值，判断a的值是是否为0，因为主内存中的a=0没有别的程序变动过，所以a肯定为0；
  3、然后main线程将a的值改为1，并刷新到主内存中，这会输出a=1；
  4、但是在thread1线程中，它是不知道主内存中的a的值被修改为1了，目前它还在使用自己工作内存中的a的值，也不知道什么时候thread1线程会去主内存中重新获取a的值，所以这里不会输出“a=1 end”结束。
  因为这里存在内存不可见问题：即main线程修改了主内存a的值，但是thread1线程无法感知到a的值被修改了。想一下，其实解决这个问题很简单，无非就是在main线程修改了a的值，并且会写到主内存之后，thread1可以知道自己工作内存中的这个a的值现在是无效的了，如果需要使用这个a，必须去主内存中重新读取a的值。刚好在Java中volatile关键字就有这种效果。volatile主要是使用计算机的M(被修改Modified)E(独享的Exclusive)S(共享的Shared)I(无效的Invalid)缓存一致性来处理这种问题。
  1、在thread1读取到a的之后，在thread1的工作内存中a会被标志为E(独享)
  2、在main线程读取了a之后，main的工作内存以及thread1的工作内存的a都会被标志为S(共享)
  3、在main线程修改了a的值，main内存中的a会被标志为M(被修改)，并写入主内存之后，thread1的工作内存中的a会被标志为I(无效)
  4、在thread1的循环中，在读取a的时候，发现自己的工作内存中的a是无效的，就会去主内存中重新读取a的值，这个时候工作内存中的a又会被标志为S(共享)

  优化代码：在变量a的前面加上volatile;

  volatile int a = 0;
  

• 防止指令重排序

  public class SingletonTest {
  
      private String word = "";
  
      public static volatile SingletonTest INSTANCE = null;
  
      private SingletonTest() {
          word = "Hello World";
          System.out.println(word);
      }
  
      /**
       * 双重检查获取单例(DCL)
       * @return new SingletonTest()
       */
      public static SingletonTest getInstance() {
          //(1)第一重检查
          if (INSTANCE == null) {
              //(2)加锁
              synchronized (SingletonTest.class) {
                  //(3)第二重检查
                  if (INSTANCE == null) {
                        //(4)获取对象
                      INSTANCE = new SingletonTest();
                  }
              }
          }
          return INSTANCE;
      }
  
      public static void main(String[] args) {
          SingletonTest singletonTest = getInstance();
      }
  }
  

  以上是一个DCL(双重检查)方式获取单例的代码。但是为什么还需要在这里加上volatile

  public static volatile SingletonTest INSTANCE = null;
  

  原因是在(4)中

  INSTANCE = new SingletonTest();
  

  这段代码在计算机底层是分了三步

  1、给SingletonTest开辟一块内存；
  2、给SingletonTest赋初始值；
  3、new SingletonTest() 赋值给INSTANCE；
  这三步中很渺小可能执行顺序为1>3>2；当3比2先执行时，这个时候当别的线程执行到了(1)时，其实INSTANCE已经不是null了，然后就返回了。很明显这个是不对的。

  • volatile如何保证有序性：

  1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

  2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。