JUC：JMM内存模型理解、Volatile关键字的理解

文章目录

• JMM(java memory model)
• Volatile 关键字
• • 保证可见性
  • volatile++复合操作不保证原子性
  • 单个volatile操作保证原子性
  • 禁止指令重排

JMM(java memory model)

什么是JMM

JMM：java内存模型(java memory model)。可理解为一种概念、约定。因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，结果就是当你的代码在某个系统环境下运行良好，并且线程安全，但是换了个系统就出现各种问题。Java内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。读写的一种规则。

内存划分

JVM在设计时候考虑到，如果JAVA线程每次读取和写入变量都直接操作主内存，对性能影响比较大，所以每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝，线程对变量的读取和写入，直接在工作内存中操作，而不能直接去操作主内存中的变量。但是这样就会出现一个问题，当一个线程修改了自己工作内存中变量，对其他线程是不可见的，会导致线程不安全的问题。因为JMM制定了一套标准来保证开发者在编写多线程程序的时候，能够控制什么时候内存会被同步给其他线程。

内存交互操作

内存交互操作有8种(4对)，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

• lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态

• unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

• read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用

• load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中

• use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令

• assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中

• store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用

• write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用，制定了如下规则：

• 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write

• 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存

• 不允许一个线程将没有assign的数据从工作内存同步回主内存

• 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作

• 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁

• 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值

• 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量

• 对一个变量进行unlock操作之前，必须把此变量同步回主内存

问题程序：

public class VolatileTest {
    private static int num = 0;
    public static void main(String[] args) throws InterruptedException { // main线程

        new Thread(()->{ // 线程1 对主内存的变化不知道
            while (num == 0){

            }
        }).start();

        TimeUnit.SECONDS.sleep(2);

        num = 1;
        System.out.println("num => "+num);
    }
}

如上程序，有两个线程，一个main线程，一个线程1。线程1被启动之后，该线程从主内存中，获取到了num值为0，此时就进入了死循环。往下，主线程修改了num的值，为1。因此主内存中的num值变了，可是线程1还是一直在死循环，这时因为，当main线程更改了num值之后，对线程1是不可见的，因此导致线程1没有重新去读取主内存的num值，却线程1的工作内存还一直是num=0的结果。

Volatile 关键字

请谈谈你对volatile的理解

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

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

保证可见性

public class VolatileTest {
    private static volatile int num = 0;
    public static void main(String[] args) throws InterruptedException { // main线程

        new Thread(()->{ // 线程1
            while (num == 0){

            }
        }).start();

        TimeUnit.SECONDS.sleep(2);

        num = 1;
        System.out.println("num => "+num);
    }
}
// 给num加了volatile关键字，当该变量值发生变化时，线程1就会重新去主内存读取，保证可见性。
// 读取之后，线程1因为不满足num==0，就会退出。

volatile++复合操作不保证原子性

原子性：不可分割。如线程A在执行任务的时候，不能被打扰，不能被分割。要么成功，要么就失败。

public class VolatileTest01 {
    private static volatile int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        // 判断线程数是否大于2，java有2个默认线程，main线程，gc线程
        while (Thread.activeCount() > 2){
            Thread.yield(); // 让线程礼让，防止一直占用cpu
        }

        System.out.println(num);
    }
}
// 输出：9965

如上程序，可见volatile是不具有原子性的，线程执行任务时，容易被扰乱。别看是一行代码num++，在汇编中num++有几行代码：

解决原子性

1. 使用lock锁或synchronized (但是消耗资源，效率不高)
2. 使用java.util.concurrent.atomic包中的类，底层是CAS，代码如下：

public class VolatileTest01 {
    // 原子性整数对象  
    private static volatile AtomicInteger atomicInteger = new AtomicInteger(0);
    public static void add(){
        atomicInteger.getAndIncrement(); // +1方法 通过CAS去操作的，见十五知识点深入理解CAS
    }
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }

        // 判断线程数是否大于2，java有2个默认线程，main线程，gc线程
        while (Thread.activeCount() > 2){
            Thread.yield(); // 让线程礼让，防止一直占用cpu
        }

        System.out.println(atomicInteger);
    }
}
// 输出：10000

单个volatile操作保证原子性

public class Test{
    volatile long v1 = 1L;
    
    public void set(Long l){
        v1 = l;
    }
}

set方法中的复制操作，即对定义了volatile的变量，是有原子性的。

禁止指令重排

指令重排：

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

处理器指令重排的时候，会考虑数据之间的依赖性。

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

我们所期望的执行顺序：1234  系统可能执行的顺序是：2134 1324 (这就是重排)
不可能是 4123

指令重排可能会导致出错

x,y,a,b默认值为0

线程A	线程B
x=a	y=b
b=1	a=2

正常输出应该是：x = 0 ； y = 0

由于各个线程执行的代码之间没有依赖关系，可能会出现以下状况：

线程A	线程B
b=1	a=2
x=a	y=b

输出异常结果：x = 2 ； y = 1；

而volatile会避免指令重排，加入了volatile关键字，会在volatile关键字上下文位置，加入cpu屏障，保证代码顺序不改变，保证不重排。