10-Volatile&保证可见性&不保证原子性&禁止指令重排

18.理解JMM

请你谈谈对Volatile的理解

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

1.保证可见性 （和JMM有关）

2.不保证原子性

3.禁止指令重排

什么是JMM

JMM ： java内存模型，不存在的东西，概念，约定

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

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中的最新值到工作内存中!

3、加锁和解锁是同一把锁

线程 工作内存 主内存

内存交互的8种操作 要成对出现

问题？

package volatilet;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    private static 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);
    }
}
 //控制台输出1 但是while还在循环

问题 :程序不知道主内存的值已经被修改过了 引出Volatile

19.Volatile

1.可见性

public class JMMDemo {
    //volatile 加了 直接结束循环
    private volatile static int num=0;
    public static void main(String[] args) {
        new Thread(()->{   //线程1对主内存的变化不知道
            while (num==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}

2.不保证原子性

原子性：不可分割

package volatilet;
//volatile 不保证原子性
public class VDemo02 {
    private volatile static int num=0;
    //加 synchronized 结果正确
    public  static void add(){
        num++; //不是一个原子性操作
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            //理论上num结果为20000
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                  add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){ //main gc
         Thread.yield();
        }
        System.out.println(num);
    }
}

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

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

package volatilet;

import java.util.concurrent.atomic.AtomicInteger;

//volatile 不保证原子性
public class VDemo02 {
    private volatile static AtomicInteger num=new AtomicInteger();
    //加 synchronized 结果正确
    public  static void add(){
        //num++;
        num.getAndIncrement();// +1 方法 , CAS
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            //理论上num结果为20000
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                  add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){ //main gc
         Thread.yield();
        }
        System.out.println(num);
    }
}

3.禁止指令重排

什么是指令重排

你写的程序，计算机并不是按照你写的那样去执行的。

源代码-> 编译器优化的重拍—>指令并行也可能会重排—>内存系统也会重排—>执行

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

我们所期望的 1234    但是可能执行的时候变成2134 1324
    
不可能是4123！
处理器在进行指令重排的时候，考虑：数据之间的依赖性！

volatile可以避免指令重排

内存屏障 ，CPU指令 作用：

1、保证特定的操作的执行顺序!
2、可以保证某些变量的内存可见性〔利用这些特性volatile实现了可见性)

Volatile是可以保持可见性。不能保证原子性，由于内存屏障，可以保证避兔指令重排的现象产生