多线程及并发面试基础（1）——谈谈volatile的理解

对多线程及并发面试基础的小总结
针对面试中的问题，用理论–代码–总结讲各个问题讲清楚。

1、谈谈你对volatile的理解

volatile是Java虚拟机提供的轻量级的同步机制。为什么这里是轻量级，而我们要把synchronized当做是重量级的锁。首先看看volatile的三个理论：

1. 保证可见性
2. 不保证原子性（该点正是volatile是轻量级的同步机制的原因）
3. 禁止指令重排

1.1 保证可见性

思考问题：
1、再多线程中访问共享变量的时候，会不会出现多线程修改共享变量导致值没有实时同步的问题？
使用volatile修饰变量，在多个线程中访问时会同步最新的值。
2、为什么使用了volatile就可以保证多线程访问共享变量时实时同步呢？

 要解释volatile的可见性，需要我们看看JMM（java 内存结构模型）。
 JMM决定一个线程对共享变量的写入何时对另一个线程可见，JMM定义了线程和主内存之间的抽象关系：共享变量存储在主内存(Main Memory)中，每个线程都有一个私有的本地内存（Local Memory），本地内存保存了被该线程使用到的主内存的副本拷贝。每次线程先去主内存中拿值放到自己的缓存中，线程对变量的所有操作都必须在自己的缓存中进行，而不能直接读写主内存中的变量。

细节流程图：

代码：

public class volatileTest {
    /*volatile*/ boolean running =true;
    void m(){
        System.out.println("m start");
        while(running){
            
        }
        System.out.println("m end");
    }
 
    public static void main(String[] args) {
        volatileTest v=new volatileTest();
        new Thread(v::m,"t1").start();
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        v.running=false;
    }
}

输入结果：m start
加了volatile之后，输出结果：m start
m end

1.2 不保证原子性

volatile不能保证原子性，这就是为什么说volatile是个轻量级的同步机制的原因。看代码：

class myData{
  volatile int num=0;
  void add(){
        for (int i = 0; i < 1000; i++) {
            num++;
        }
  }
}

public class volatileTest {
    public static void main(String[] args) {
        myData myData = new myData();
		for (int i = 0; i<10 ; i++) {
             new Thread(()->{
                 myData.add();
             },String.valueOf(i)).start();
         }
        System.out.println(myData.atomicInteger);
    }
}

输出结果：9870、9456…
如果保证了原子性，这里应该输出10000，因为num++本来就不是源自操作。1.读取 2.加一 3.赋值 三步组成。
　　所以，在多线程环境下，有可能线程A将num读取到本地内存中，此时其他线程可能已经将num增大了很多，线程A依然对过期的num进行自加，重新写到主存中，最终导致了num的结果不合预期，而是小于100000。

1.3 禁止指令重排（有序性）

指令重排：多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

指令重排过程：
源代码 -> 编辑器优化的重排 -> 指令并行的重排 -> 内存系统的重排 ->最终执行的指令

但是加了volatile的关键字之后就禁止电脑进行指令重排，从而避免多线程环境下程序出现乱序执行的现象

public void mySort(){
	int x=11;//语句1
    int y=12;//语句2
    x=x+5;//语句3
    y=x*x;//语句4
}
执行的时候，执行顺序可能变成如下：
1234
2134
1324
问题:
请问语句4 可以重排后变成第一条码?
不能，存在数据的依赖性 没办法排到第一个

1.4 volatile可见性和禁止指令重排原理？
volatile 可以保证线程可见性且提供了一定的有序性，但是无法保证原子性。在 JVM 底层是基于内存屏障实现的。

当对非 volatile 变量进行读写的时候，每个线程先从内存拷贝变量到 CPU 缓存中。如果计算机有多个CPU，每个线程可能在不同的 CPU 上被处理，这意味着每个线程可以拷贝到不同的 CPU cache 中
而声明变量是 volatile 的，JVM 保证了每次读变量都从内存中读，跳过 CPU cache 这一步，所以就不会有可见性问题
对 volatile 变量进行写操作时，会在写操作后加一条 store 屏障指令，将工作内存中的共享变量刷新回主内存；
对 volatile 变量进行读操作时，会在写操作后加一条 load 屏障指令，从主内存中读取共享变量；

1.5 你在哪些地方用到过volatile

单例模式DCL代码，这里为什么要用到volatile（禁止指令重排）

/***
 * 双重检测机制
 */
public class SingletonDemo {
    private static **volatile** SingletonDemo single = null;
    private SingletonDemo() {}

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

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

思考一个问题：为什么单例里面加了锁还需要volatile修饰。
DCL(双端检锁) 机制不一定线程安全,原因是有指令重排的存在,加入volatile可以禁止指令重排

原因在于某一个线程在执行到第一次检测,读取到的instance不为null时,instance的引用对象可能没有完成初始化.
instance=new SingletonDem(); 可以分为以下步骤(伪代码)
memory=allocate();//1.分配对象内存空间
instance(memory);//2.初始化对象
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null 步骤2和步骤3不存在数据依赖关系.而且无论重排前还是重排后程序执行的结果在单线程中并没有改变,因此这种重排优化是允许的.
memory=allocate();//1.分配对象内存空间
instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null 但对象还没有初始化完.
instance(memory);//2.初始化对象
但是指令重排只会保证串行语义的执行一致性(单线程) 并不会关心多线程间的语义一致性。所以当一条线程访问instance不为null时,由于instance实例未必完成初始化,也就造成了线程安全问题.

volatile总结： 1、保证可见性 2、不保证原子性 3、禁止指令重排
volatile使用场景，单理模式中的应用。包括很多源码中的共享变量也使用volatile关键子修饰。

volatile不能保证原子性，那么多线程对num++怎么操作呢？
使用并发包中的原子操作类。

下一章就是并发包中的原子操作类的讲解应用。