JUC学习笔记七：JMM

1.谈谈对volatile的理解

Volatile是java提供的轻量级的同步机制，有以下特点：

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

在解释这三个特性之前，我们先来了解一下JMM

2.JMM

JMM全称是Java内存模型，是一种概念性的东西，不是真实存在的
他其实是java为了管理内存数据安全而提出的一种解决方案

在程序运行中，其实存在两种内存，一个称为主存，一个称为工作内存。数据在不使用的时候都是存放在主存的，当有个线程任务需要这个数据的时候，就先把数据载入到工作内存使用，用完再把数据刷新回主存。

那么在主存和工作内存之间就存在8中操作，来保证数据的安全性
1.read load
2.use assign
3.write store
4.lock unlock

这四种操作应该是成对进行的，保证操作的原子性，不可再分的

• lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
• unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
• read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
• load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
• use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
• assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
• store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
• write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

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操作之前，必须把此变量同步回主内存

3.Volatile

1.保证可见性

public class JMMDemo {
    //加了Volatile关键字以后就会使得这个变量对其他线程都是可见的
    private volatile static int num=0;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{ //这个线程对主内存的变化是不知道的，所以就会一直处于死循环
            while (num==0){

            }
        }).start();

        TimeUnit.SECONDS.sleep(2);
        num=1;
        System.out.println(num);
    }
}

2.不保证原子性

所谓原子性：就是不可分割，在执行一个任务的时候，要么全部成功要吗全部失败

package com.ycm.tvolatile;

public class JMMDemo02 {
    // volatile 不保证原子性
    private volatile static int num = 0;

    public static void add() {
        num++;
    }

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

                    add();
                }
            }).start();
        }

        //当前线程的数量，正常程序至少会有两个线程：main---GC
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

程序如果正常执行，那么就会打印20000，但是结果如下：

说明加了volatile不能保证原子性

那么现在的问题是如何保证其原子性？
或许有人会想到用lock或者synchronized，是的，这两个方法确实可以起到效果，但是还有没有别的方法？
那么还有另一个方法，那就是使用JUC包下的原子类来解决原子问题

package com.ycm.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

public class JMMDemo02 {
    // volatile 不保证原子性

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

    public static void add() {
        num.getAndIncrement();//+1
    }

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

                    add();
                }
            }).start();
        }

        //当前线程的数量，正常程序至少会有两个线程：main---GC
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

那么结果也正如我们想要的

3.指令重排

什么是指令重排？
简单的说：就是你写的程序，在计算机里面并不是按照你写的那样的顺序去执行。它会进行指令重排。一般要经过如下步骤：
源代码–》编译器优化的重排–》指令并行重排–》内存系统重排–》》执行

使用volatile可以避免指令重排的原理：
在加了volatile关键字的变量，就可以实现变量的可见性，那么在对变量进行操作的时候，就会在这个操作的前后做一个内存屏障的东西，目的是让这个变量的上下指令不要进行重排