面试高频JMM、volatile，如何搞定

JMM java内存模型

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

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

java内存模型，不存在的东西，概念，约定

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

线程有工作内存和主内存
8种操作，必须成对出现

问题：如下图，当主存中的num值修改后如何通知线程A num值已经修改了？

import java.util.concurrent.TimeUnit;public class VolitailDemo {
    private 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:"+num);}
}

验证volatile的3大特性

1.可见性

解决了上述线程对主内存的变化不知道的情况

不加volatile 会死循环

import java.util.concurrent.TimeUnit;public class VolitailDemo {
    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:"+num);}
}

2.不保证原子性

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

如果add（）任务具有原子性的话，num输出值是80_0000,
但使用volatile 之后每次执行结果基本会变化，小于这个值

public class Yuanzi {
    private volatile static int num=0;
// add() 方法上加synchronized可以实现add的原子性public  static void add(){
    num++;}public static void main(String[] args) {
    for (int i = 0; i < 8; i++) {
    new Thread(()->{
    for (int i1 = 0; i1 < 10_0000; i1++) {
    add();}}).start();}while (Thread.activeCount()>2)//默认有main和gc线程{
    Thread.yield();//礼让}System.out.println(Thread.currentThread().getName()+" --->"+num);}
}

如何不加lock或者synchronized，如何保证原子性

使用原子类

import java.util.concurrent.atomic.AtomicInteger;public class AtmicPro {
    private static AtomicInteger num = new AtomicInteger(0);public static void add(){
    num.getAndIncrement();//原子性的+1操作}public static void main(String[] args) {
    for (int i = 0; i < 8; i++) {
    new Thread(()->{
    for (int i1 = 0; i1 < 10_0000; i1++) {
    add();}}).start();}while (Thread.activeCount()>2)//默认有main和gc线程{
    Thread.yield();//礼让}System.out.println(Thread.currentThread().getName()+" --->"+num);}
}

这些类的底层和操作系统挂钩

指令重排序

为了提高效率，保证了数据之间的依赖性

例子：对象的创建过程
创建->初始化->建立连接
1.申请内存空间，默认初始值为0
2.构造方法赋值
3.建立连接
正常走1 2 3 顺序，有时可能会1 3 2

volatile可以避免指令重排
原理是内存屏障 ：
保证特定操作的执行顺序
可以保证某些变量的内存可见性