Volatile关键字

public class MyThread extends Thread{
    public static void main(String[] args) {
        MyThreadTest myThread = new MyThreadTest();
        //开启线程
        myThread.start();
        //主线程执行
        for (;;){
            synchronized (myThread){
                if(myThread.isFlag()){
                    System.out.println("main线程访问到了flag变量");
                }
            }
        }
    }
}
/**
 * 创建线程有四种方法，这里使用的是继承Thread接口，实现run()方法
 */
@Data
class MyThreadTest extends Thread{
    private boolean flag = false;
    @Override
    public void run(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //修改上面变量的值
        flag = true;
        System.out.println("flag = "+ flag);
    }
}

为什么加了锁以后就保证了变量的内存可见性呢？

因为当一个线程进入synchronized代码块后，线程获取到锁，会清空本地内存，然后从主内存中拷贝共享变量的最新值到本地内存作为副本。然后将修改后的副本值刷新到主内存中，执行代码，最后线程释放锁。

第二种：共享变量修饰共享变量

package com.lsf.demo.test;

import lombok.Data;

public class MyThread extends Thread{
    public static void main(String[] args) {
        MyThreadTest myThread = new MyThreadTest();
        //开启线程
        myThread.start();
        //主线程执行
        for (;;){

                if(myThread.isFlag()){
                    System.out.println("main线程访问到了flag变量");
                }

        }
    }
}
/**
 * 创建线程有四种方法，这里使用的是继承Thread接口，实现run()方法
 */
@Data
class MyThreadTest extends Thread{
    private volatile boolean flag = false;
    @Override
    public void run(){
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //修改上面变量的值
        flag = true;
        System.out.println("flag = "+ flag);
    }
}

为什么说加上了volatile就可以保证可见性了呢？volatile做了点什么

使用volatile修饰共享变量后，每个线程要操作共享变量时都会从主内存中加载到自己线程中的本地内存作为副本，当线程变量操作副本并写回主内存后，会通过CPU总线嗅探机制告知其他线程变量副本已经失效，需要重新从主内存中获取共享变量。

volatile保证了不同线程对共享变量操作的可见性，也就是说一个线程修改了volatile修饰的变量，当修改后的变量写回主内存时，其他线程能立即看到最新值。

总线嗅探机制

在现代计算机中，CPU的速度是极高的，如果CPU需要存取数据时都直接与内存打交道，在存取过程中，CPU将一直空闲，这是一种极大的浪费，所以，为了提高处理速度，CPU不直接和内存进行通信，而是在CPU与内存之间加入了很多寄存器，多级缓存，他们比内存的存取速度高得多，这样就解决了CPU运算速度和内存存取速度不一致问题。

工作原理

由于CPU与内存之间加入了缓存，在进行数据操作时，先将数据从内存拷贝到缓存中，CPU直接操作的是缓存中的数据。但在多处理器下，将可能导致各自的缓存数据不一致(这也是可见性问题的由来)。为了保证各个处理器的缓存是一直的，就会实现一致性协议，而嗅探是实现缓存一直性的常见机制。

每个处理器通过监听在总线上传播的数据来检查自己的缓存是不是过期了，如果处理器发现自己缓存行对应的内存地址修改，就会将当前处理器的缓存行设置无效状态，当处理器对这个数据进行修改操作的时候，会重新从主内存中把数据读到处理器缓存中。

总线风暴

基于CPU缓存一致性协议，JVM实现了volatile的可见性，但由于总线嗅探机制，会不断的监听总线，如果大量使用volatile会引起总线风暴。所以，volatile的使用要适合具体场景。

如何保证原子性

volatile无法保证原子性。所谓的原子性是指在一次操作或者多次操作中，要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，要么所有的操作都不执行。在多线程环境下，volatile关键字可以保证共享数据的可见性，但是并不能保证对数据操作的原子性。也就是说，多线程环境下，多线程环境下，使用volatile修饰的变量时线程不安全的。我们可以使用锁(synchronized)机制，或者使用原子类(如AtomicInteger)。

class MyNumber
{
    volatile int number = 0;

    public void addPlusPlus()
    {
        number++;
    }
}

public class VolatileNoAtomicDemo
{
    public static void main(String[] args) throws InterruptedException
    {
        MyNumber myNumber = new MyNumber();

        for (int i = 1; i <=10; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    myNumber.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        
        //暂停几秒钟线程
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println(Thread.currentThread().getName() + "\t" + myNumber.number);
    }
}

从i++的字节码角度说明：

原子性指的是一个操作是不可中断的，即使是在多线程环境下，一个操作一旦开始就不会被其他线程影响。
public void add()
{
        i++; //不具备原子性，该操作是先读取值，然后写回一个新值，相当于原来的值加上1，分3步完成
 }
如果第二个线程在第一个线程读取旧值和写回新值期间读取i的域值，那么第二个线程就会与第一个线程一起看到同一个值，
并执行相同值的加1操作，这也就造成了线程安全失败，因此对于add方法必须使用synchronized修饰，以便保证线程安全.

多线程环境下，"数据计算"和"数据赋值"操作可能多次出现，即操作非原子。若数据在加载之后，若主内存count变量发生修改之后，由于线程工作内存中的值在此前已经加载，从而不会对变更操作做出相应变化，即私有内存和公共内存中变量不同步，进而导致数据不一致
对于volatile变量，JVM只是保证从主内存加载到线程工作内存的值是最新的，也就是数据加载时是最新的。
由此可见volatile解决的是变量读时的可见性问题，但无法保证原子性，对于多线程修改共享变量的场景必须使用加锁同步

禁止指令重排序

为了提高性能，编译器和处理器常常会对既定的代码执行顺序

进行指令重排序。

一个好的内存模型实际上会放松对处理和编译器的束缚，也就是说软件技术和硬件技术都为同一个目标，而进行奋斗：在不改变程序执行结果的前提下，尽可能提高执行效率。

JMM对底层尽量减少约束，使其能够发挥自身优势。

因此，在执行程序时，为了提高性能，编译器和处理器常常会对执行进行重排序。

一般重排序可以分为三种：

编译器优化的重排序：编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
指令级并行的重排序：现代处理器采用了指令级并行技术来讲多条指令进行重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序：由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行的。

volatile关键字可以保证指令重排序

volatile的底层是通过内存屏障来禁止指令重排的。

什么是内存屏障呢？

内存屏障（也称内存栅栏，内存栅障，屏障指令等，是一类同步屏障指令，是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。内存屏障其实就是一种JVM指令，Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令，通过这些内存屏障指令，volatile实现了Java内存模型中的可见性和有序性，但volatile无法保证原子性。

内存屏障之前的所有写操作都要回写到主内存，内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性)。

内存屏障的分类

内存屏障可以分为两大类：读屏障和写屏障

也可以细分为4个屏障：读读屏障、读写屏障、写写屏障、写读屏障

屏障类型	指令示例	说明
LoadLoad	Load；LoadLoad；Load2	保证load1的读取操作在load2及后续读取操作之前执行
StoreStore	Store1；StoreStore；Store2	在store2及其后的写操作执行前，保证store1的写操作已经刷新到主内存
LoadStore	Load1；LoadStore；Store2	在store2及其后的写操作执行前，保证laod1的读操作已读取结束
StoreLoad	Store1；StoreLoad；Load2	保证store1的写操作已经刷新到主内存之后，load2及其后的读操作才能执行

JMM 就将内存屏障插⼊策略

写
- 在每个 volatile 写操作的前⾯插⼊⼀个 StoreStore 屏障
- 在每个 volatile 写操作的后⾯插⼊⼀个 StoreLoad 屏障
读
- 在每个 volatile 读操作的后⾯插⼊⼀个 LoadLoad 屏障
- 在每个 volatile 读操作的后⾯插⼊⼀个 LoadStore 屏障

例如：

保证可见性

public class VolatileSeeDemo
{
    static          boolean flag = true;       //不加volatile，没有可见性
    //static volatile boolean flag = true;       //加了volatile，保证可见性

    public static void main(String[] args)
    {
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t come in");
            while (flag)
            {

            }
            System.out.println(Thread.currentThread().getName()+"\t flag被修改为false,退出.....");
        },"t1").start();

        //暂停2秒钟后让main线程修改flag值
        try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

        flag = false;

        System.out.println("main线程修改完成");
    }
}

不加volatile，没有可见性，程序无法停止
加了volatile，保证可见性，程序可以停止

线程t1中为何看不到被主线程main修改为false的flag的值？
 
问题可能:
1. 主线程修改了flag之后没有将其刷新到主内存，所以t1线程看不到。
2. 主线程将flag刷新到了主内存，但是t1一直读取的是自己工作内存中flag的值，没有去主内存中更新获取flag最新的值。
 
我们的诉求：
1.线程中修改了工作内存中的副本之后，立即将其刷新到主内存；
2.工作内存中每次读取共享变量时，都去主内存中重新读取，然后拷贝到工作内存。
 
解决：
使用volatile修饰共享变量，就可以达到上面的效果，被volatile修改的变量有以下特点：
1. 线程中读取的时候，每次读取都会去主内存中读取共享变量最新的值，然后将其复制到工作内存
2. 线程中修改了工作内存中变量的副本，修改之后会立即刷新到主内存

volatile变量的读写过程

Java内存模型中定义的8种工作内存与主内存之间的原子操作 read(读取)→load(加载)→use(使用)→assign(赋值)→store(存储)→write(写入)→lock(锁定)→unlock(解锁)

read: 作用于主内存，将变量的值从主内存传输到工作内存，主内存到工作内存

load: 作用于工作内存，将read从主内存传输的变量值放入工作内存变量副本中，即数据加载

use: 作用于工作内存，将工作内存变量副本的值传递给执行引擎，每当JVM遇到需要该变量的字节码指令时会执行该操作

assign: 作用于工作内存，将从执行引擎接收到的值赋值给工作内存变量，每当JVM遇到一个给变量赋值字节码指令时会执行该操作

store: 作用于工作内存，将赋值完毕的工作变量的值写回给主内存

write: 作用于主内存，将store传输过来的变量值赋值给主内存中的变量由于上述只能保证单条指令的原子性，针对多条指令的组合性原子保证，没有大面积加锁，所以，

JVM提供了另外两个原子指令：

lock: 作用于主内存，将一个变量标记为一个线程独占的状态，只是写时候加锁，就只是锁了写变量的过程。

unlock: 作用于主内存，把一个处于锁定状态的变量释放，然后才能被其他线程占用