JUC(八) JMM volatile

对Volatile 的理解

• Volatile 是 Java 虚拟机提供 轻量级 的同步机制
• 1、保证可见性
• 2、不保证原子性
• 3、禁止指令重排

什么是JMM？

• JMM：JAVA内存模型，不存在的东西，是一个概念，也是一个约定！

关于JMM的一些同步的约定：

•     线程解锁前，必须把共享变量立刻刷回主存；
•     线程加锁前，必须读取主存中的最新值到工作内存中；
•     加锁和解锁是同一把锁；

上面这图画错了，Store要在Write前面

8种操作如下：

• lock(锁定)：作用于主内存，它把一个变量标记为一条线程独占状态；

• read(读取)：作用于主内存，它把变量值从主内存传送到线程的工作内存中，以便随后的load动作使用；

• load(载入)：作用于工作内存，它把read操作的值放入工作内存中的变量副本中；

• use(使用)：作用于工作内存，它把工作内存中的值传递给执行引擎，每当虚拟机遇到一个需要使用这个变量的指令时候，将会执行这个动作；

• assign(赋值)：作用于工作内存，它把从执行引擎获取的值赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的指令时候，执行该操作；

• store(存储)：作用于工作内存，它把工作内存中的一个变量传送给主内存中，以备随后的write操作使用；

• write(写入)：作用于主内存，它把store传送值放到主内存中的变量中。

• unlock(解锁)：作用于主内存，它将一个处于锁定状态的变量释放出来，释放后的变量才能够被其他线程锁定；

JMM对这8种操作给了相应的规定：

• 必须成对出现，不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
• 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
• 不允许一个线程将没有assign的数据从工作内存同步回主内存
• 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是对变量实施use、store操作之前，必须经过assign和load操作
• 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
• 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
• 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
• 对一个变量进行unlock操作之前，必须把此变量同步回主内存

volatile

private static int num = 0;
   public static void main(String[] args) throws InterruptedException {//main线程
       new Thread(()->{//线程1 对主内存的变化是不知道的
           while (num == 0) {

           }
       }).start();
       TimeUnit.SECONDS.sleep(1);
       num = 1;
       System.out.println(num);
       //程序一直在执行,线程1不知道主存中的值发生了变化
   }

问题：程序一直在执行,线程1不知道主存中的值发生了变化

可见性

public class JMMDemo {
    private static volatile int num = 0;

    public static void main(String[] args) {
        new Thread(()->{     
            while (num == 0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);
    }
}

加  volatile

private static volatile int num = 0;

不保证原子性

原子性:不可分割（同时成功或失败）
线程a在执行任务的时候,不能被打扰,也不能被分割,要么同时成功,要么同时失败

public class JMMDemo {

    // volatile 不保证原子性
    private static volatile int num = 0;

    public static void add(){
        num++; //不是一个原子性操作
    }

    //num 理论上结果应该是20000

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount() > 2) { //main gc
            Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+ " " + num);
    }
}

运行结果

无法保证原子性 volatile 不保证原子性

问题：如果不加lock和synchronized ，怎么样保证原子性？

add底层操作

（1）栈中取出i

（2）i自增1

（3）将i存到栈

所以num++不是原子性操作

使用原子类 解决原子性问题

 // 原子类的 Integer
    private static volatile AtomicInteger num = new AtomicInteger();

    public static void add(){
        num.getAndIncrement(); //AtomicInteger的+1方法，底层CAS
    }

原子类为什么这么高级？
这些类的底层都直接和操作系统挂钩！是在内存中修改值。
Unsafe类是一个很特殊的存在；

禁止指令重排

什么是指令重排？

• 我们写的程序，计算机并不是按照我们自己写的那样去执行的
• 源代码–>编译器优化重排–>指令并行也可能会重排–>内存系统也会重排–>执行
• 处理器在进行指令重排的时候，会考虑数据之间的依赖性！

int x=1; //1
int y=2; //2
x=x+5;   //3
y=x*x;   //4

//我们期望的执行顺序是 1_2_3_4  可能执行的顺序会变成2134 1324
//可不可能是 4123，1423？ 不可能的
1234567

可能造成的影响结果：前提：a b x y这四个值 默认都是0

正常的结果： x = 0; y =0;

可能在线程A中会出现，先执行b=1,然后再执行x=a；
在B线程中可能会出现，先执行a=2，然后执行y=b；
那么就有可能结果如下：x=2; y=1.

volatile可以避免指令重排：

• volatile中会加一道内存的屏障，这个内存屏障可以保证在这个屏障中的指令顺序。
• 内存屏障：CPU指令。作用：
  •  1、保证特定的操作的执行顺序；
  •  2、可以保证某些变量的内存可见性（利用这些特性，就可以保证volatile实现的可见性）

只有加voliate才会有上下内存屏障

总结

•     volatile可以保证可见性；
•     不能保证原子性
•     由于内存屏障，可以保证避免指令重排的现象产生

在哪里用这个内存屏障用得最多呢？单例模式