谈谈对Volatile的理解

• JUC（java.util.concurrent）
  • 进程和线程
    • 进程：后台运行的程序（我们打开的一个软件，就是进程）
    • 线程：轻量级的进程，并且一个进程包含多个线程（同在一个软件内，同时运行窗口，就是线程）
  • 并发和并行
    • 并发：同时访问某个东西，就是并发
    • 并行：一起做某些事情，就是并行
• JUC下的三个包
  • java.util.concurrent
    • java.util.concurrent.atomic
    • java.util.concurrent.locks

谈谈对Volatile的理解

Volatile在日常的单线程环境是应用不到的

• Volatile是Java虚拟机提供的轻量级的同步机制（三大特性）
  • 保证可见性
  • 不保证原子性
  • 禁止指令重排

JMM是什么

JMM是Java内存模型，也就是Java Memory Model，简称JMM，本身是一种抽象的概念，实际上并不存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式

JMM关于同步的规定：

• 线程解锁前，必须把共享变量的值刷新回主内存
• 线程解锁前，必须读取主内存的最新值，到自己的工作内存
• 加锁和解锁是同一把锁

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写会主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储着主内存中的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成，其简要访问过程：

数据传输速率：硬盘 < 内存 < < cache < CPU

上面提到了两个概念：主内存 和 工作内存

• 主内存：就是计算机的内存，也就是经常提到的8G内存，16G内存

• 工作内存：但我们实例化 new student，那么 age = 25 也是存储在主内存中

  • 当同时有三个线程同时访问 student中的age变量时，那么每个线程都会拷贝一份，到各自的工作内存，从而实现了变量的拷贝

即：JMM内存模型的可见性，指的是当主内存区域中的值被某个线程写入更改后，其它线程会马上知晓更改后的值，并重新得到更改后的值。

缓存一致性

为什么这里主线程中某个值被更改后，其它线程能马上知晓呢？其实这里是用到了总线嗅探技术

在说嗅探技术之前，首先谈谈缓存一致性的问题，就是当多个处理器运算任务都涉及到同一块主内存区域的时候，将可能导致各自的缓存数据不一。

为了解决缓存一致性的问题，需要各个处理器访问缓存时都遵循一些协议，在读写时要根据协议进行操作，这类协议主要有MSI、MESI等等。

MESI

当CPU写数据时，如果发现操作的变量是共享变量，即在其它CPU中也存在该变量的副本，会发出信号通知其它CPU将该内存变量的缓存行设置为无效，因此当其它CPU读取这个变量的时，发现自己缓存该变量的缓存行是无效的，那么它就会从内存中重新读取。

总线嗅探

那么是如何发现数据是否失效呢？

这里是用到了总线嗅探技术，就是每个处理器通过嗅探在总线上传播的数据来检查自己缓存值是否过期了，当处理器发现自己的缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置为无效状态，当处理器对这个数据进行修改操作的时候，会重新从内存中把数据读取到处理器缓存中。

总线风暴

总线嗅探技术有哪些缺点？

由于Volatile的MESI缓存一致性协议，需要不断的从主内存嗅探和CAS循环，无效的交互会导致总线带宽达到峰值。因此不要大量使用volatile关键字，至于什么时候使用volatile、什么时候用锁以及Syschonized都是需要根据实际场景的。

JMM的特性

JMM的三大特性，volatile只保证了两个，即可见性和有序性，不满足原子性

• 可见性
• 原子性
• 有序性

可见性代码验证

但我们对于成员变量没有添加任何修饰时，是无法感知其它线程修改后的值

package com.qcby.bilbil.gc;

import java.util.concurrent.TimeUnit;

/**
 * @author HuangHaiyang
 * @date 2020/08/18
 * @description: description
 * @version: 1.0.0
 */


class MyData{
    int number=0;

    public void addNumber(){
        this.number = 60;
    }
}
public class VolatileDemo {
    public static void main(String[] args) {

        //资源类
        MyData myData = new MyData();

        new Thread(()->{
            System.out.println("AA线程开始对number的写入number=:"+myData.number);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.addNumber();
            System.out.println("AA线程结束对number的写入number=:"+myData.number);
        },"AA线程").start();


        //另一个线程为main线程

        while (myData.number==0){
            //只要number==0就一直等待，直到number！=0
        }
        System.out.println("main 线程 结束 number=:"+myData.number);
    }
}

输出结果为

//AA线程开始对number的写入number=:0
//AA线程结束对number的写入number=:60

最后线程没有停止，并行没有输出 main 线程 结束 这句话，说明没有用volatile修饰的变量，是没有可见性.

当我们修改MyData类中的成员变量时，并且添加volatile关键字修饰

class MyData {
    /**
     * volatile 修饰的关键字，是为了增加 主线程和线程之间的可见性，只要有一个线程修改了内存中的值，其它线程也能马上感知
     */
    volatile int number = 0;

    public void addNumber(){
        this.number = 60;
    }
}

最后输出的结果为：

//AA线程开始对number的写入number=:0
//AA线程结束对number的写入number=:60
//main 线程 结束 number=:60

主线程也执行完毕了，说明volatile修饰的变量，是具备JVM轻量级同步机制的，能够感知其它线程的修改后的值。