volatile是Java虚拟机提供的轻量级同步机制

volatile是Java虚拟机提供的轻量级同步机制

• 保证可见性
• 不保证原子性
• 禁止指令重排

JMM

    1、可见性
    2、原子性
    3、有序性
 概念：Java 内存模型 Java Memory Model，是一种抽象概念并不真实存在，它描述的是一种规则或规范，通过这组规范定义了程序中各个变量的访问方式。
 
 JMM 同步规定：
 1、线程解锁前，必须把共享变量的值刷新回主内存。
 2、线程加锁前，必须读取主内存种的最新值到自己的工作区。
 3、加锁和解锁必须是同一把锁。

保证可见性

    1.1 假如number = 0，number变量之前根本没有添加volatile关键字，没有可见性
    1.2 添加volatile，可解决可见性的问题
 

不保证原子性

    2.1 原子性是指？
        不可分割，完整性。也就是某个线程保证具体业务时，中间不可以被加塞或分割，需要整体完整
    要么同时成功，要么同时失败
 
    2.2 如何解决原子性
       2.2.1、加synchronized
       2.2.2、使用juc下的AtomicInteger 底层 CAS
    
    3.1 CAS
        思想很简单：三个参数，一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。
    3.2 可能会有面试官问 CAS 底层是如何实现的，在JAVA中,CAS通过调用C++库实现，由C++库再去调用CPU指令集。

指令重排

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排，一般分为以下 3 种

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

单线程环境里面确保程序最终执行的结果和代码执行的结果一致
处理器在进行重排序时必须考虑指令之间的数据依赖性

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

禁止指令排序

volatile 实现禁止指令重排序的优化，从而避免了多线程环境下程序出现乱序的现象

先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个 CPU 指令，他的作用有两个：

• 保证特定操作的执行顺序
• 保证某些变量的内存可见性（利用该特性实现 volatile 的内存可见性）

由于编译器个处理器都能执行指令重排序优化，如果在指令间插入一条 Memory Barrier 则会告诉编译器和 CPU，不管什么指令都不能个这条 Memory Barrier 指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后执行重排序优化。内存屏障另一个作用是强制刷出各种 CPU 缓存数据，因此任何 CPU 上的线程都能读取到这些数据的最新版本。

测试代码

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author : x
 * @cllassName : Demo
 * @date :  2021/8/4 2:16 下午
 * @description: volatile可见性
 *
 *   1. 验证volatile的可见性
 *   1.1 假如number = 0，number变量之前根本没有添加volatile关键字，没有可见性
 *   1.2 添加volatile，可解决可见性的问题
 *   2. 验证volatile不保证原子性
 *   2.1 原子性是指？
 *          不可分割，完整性。也就是某个线程保证具体业务时，中间不可以被加塞或分割，需要整体完整
 *          要么同时成功，要么同时失败
 *
 *   2.2 如何解决原子性
 *      2.2.1、加synchronized
 *      2.2.2、使用juc下的AtomicInteger 底层 CAS
 **/
class MyDate {
//    int number = 0;
    volatile int number = 0;

    //验证可见性
    public void add() {
        this.number = 20;
    }


    //验证不保证原子性
    public void addPlus1() {
        this.number++;
    }

    //验证保证原子性方法1
    public synchronized void addPlus2() {
        this.number++;
    }

    //验证保证原子性方法2
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic() {
        atomicInteger.getAndIncrement();
    }
}

public class Demo {
    public static void main(String[] args) {
        System.out.println("-----------------------项目启动了。。。。");
        // 保证可见性
        seeOkVolatile();
        // 不保证原子性

        // 禁止指令重排
    }
    /**
     * 1
     * 保证可见性
     */
    private static void seeOkVolatile() {
        MyDate date = new MyDate();
        System.out.println(Thread.currentThread().getName() + " coming...");
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " coming...");
            try {
                TimeUnit.SECONDS.sleep(3);         //暂停3秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            date.add();
            System.out.println(Thread.currentThread().getName() + "   update number" + date.number);
        },"AAAA").start();

        while (date.number == 0) {

        }

        System.out.println(Thread.currentThread().getName() + "   mission is over , get numder value : " + date.number);
    }

    /**
     * 2
     * 不保证原子性  addPlus1()
     * 保证原子性   addPlus2()
     * 保证原子性   addPlus3().
     */
    private static  void sysOKVolatile(){
        MyDate date = new MyDate();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    date.addPlus1();    //不保证原子性
                    //date.addPlus2();    //保证原子性
                    //date.addAtomic();    //保证原子性
                }
            },String.valueOf(i)).start();

        }
        // 默认有 main 线程和 gc 线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        //输出值
        System.out.println(Thread.currentThread().getName() + '\t' + date.number);
        System.out.println(Thread.currentThread().getName() + '\t' + date.atomicInteger);
    }
}