面试高频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可以避免指令重排
原理是内存屏障 ：
保证特定操作的执行顺序
可以保证某些变量的内存可见性