volatile

volatile

Java虚拟机提供的轻量级的同步机制

三大特性

• 保证可见性

  案例：

  package com.example.demo.juc;
  
  import java.security.interfaces.DSAPublicKey;
  import java.util.concurrent.TimeUnit;
  
  /**
   * @Author: junwe
   * @Date: 2021/3/14 17:44
   */
  public class VolatileSee {
  
  //    int number = 0;
      volatile int number = 0;
      public void change(){
          number = 20;
      }
  
      public static void main(String[] args) {
          VolatileSee see = new VolatileSee();
          new Thread(()->{
              System.out.println(Thread.currentThread().getName()+" come in");
              try {
                  TimeUnit.SECONDS.sleep(3L);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              see.change();
              System.out.println(Thread.currentThread().getName()+" end");
          },"A").start();
  
          while (see.number == 0){}
  
          System.out.println(Thread.currentThread().getName()+" end");
      }
  }
  

  当变量number没有volatile修饰时，程序将一直再while循环中。加了volatile后3秒后正常退出。

• 不保证原子性

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

  案例：

  package com.example.demo.juc;
  
  /**
   * @Author: junwe
   * @Date: 2021/3/21 16:00
   */
  public class VolatileAtomic {
      volatile int i = 0;
  
      public void add() {
          i++;
      }
  
      public static void main(String[] args) {
          VolatileAtomic volatileAtomic = new VolatileAtomic();
          for (int i = 0; i < 20; i++) {
              new Thread(() -> {
                  for (int i1 = 0; i1 < 1000; i1++) {
                      volatileAtomic.add();
                  }
              }, String.valueOf(i)).start();
          }
  
          // 等待上面20个线程执行完毕，只剩下main线程和gc线程
          while (Thread.activeCount() > 2) {
              Thread.yield();
          }
  
          System.out.println(Thread.currentThread().getName() + ":" + volatileAtomic.i);
      }
  }
  

  执行结果

  

  通过查看字节码指令可以看出i++被拆分成三个指令：

  执行getfield拿到原始值；

  执行iadd执行加1操作；

  putfield把累加后的值写回；

  

  如何解决原子性：

  1. 加锁
  2. 使用AtomicInteger

• 禁止指令重排

  volatile使用内存屏障（memory barrier），一个CPU指令，来禁止指令重排。它的作用有两个：

  1. 保证特定操作的执行顺序
  2. 保证某些变量的可见性

  编译器和处理器都能执行指令重排优化。如果在指令间插入一条memory barrier则会告诉编译器和CPU，禁止在内存屏障前后的指令执行重排序优化。内存屏障的另外一个作用是强制刷出CPU的缓存数据，因此任何CPU上的线程都能读到这些数据的最新版本。

  指令重排只会保证串行语义执行的一致性（单线程），并不关心多线程间语义的一致性。

JMM（Java内存模型）

JMM关于同步的规定：

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

每个线程创建时JVM都会为其创建一个工作内存（栈空间），工作内存是每个线程私有的，而Java内存模型中规定所有的变量都存储在主内存，主内存是共享的，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行。各线程首先将变量从主内存拷贝到各自的工作内存中，然后对变量进行操作，操作完成后再将变量写回到主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着从主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信必须通过主内存来完成，简要的访问过程如下：

工作内存和主内存同步延迟导致的可见性问题可以使用synchronized或volatile关键字解决，他们都可以保证修改后的变量立即对其他线程可见。对于指令重排导致的可见性和有序性问题，可以利用volatile关键字解决。

应用

单例模式（DCL双端检锁机制）

package com.example.demo;

/**
 * @Author: junwe
 * @Date: 2021/3/21 21:20
 */
public class Singleton {
    private static volatile Singleton instance = null;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

instance = new Singleton()不是原子操作，可以分为三步：

1. 分配对象内存空间
2. 初始化对象
3. 设置instance指向刚分配的内存地址，此时instance!=null

如果发生了指令重排，执行顺序就有可能变为1-3-2。在执行到3的时候，如果此时有另外一个线程调用getInstance()方法，这个时候返回的对象就有可能是还未初始化的对象。