前言
关于JMM的内容其实并不多，指令重排，可见性，原子性，就这三大块，这次的简单总结，并没有过多深入总结，也只是总结面试上的内容，本篇博客简单说一下原子性，并总结一下JMM中的相关面试问题
原子性
要说到什么是原子性，其实这个应该学过计算机的同学都应该知道，每次聊到原子性，都会老生常谈的几个实例也就是那几个，无非就是转账要么全部成功，要么全部失败，其操作组合是一个原子性的。
其实通俗点理解就是一系列的操作，要么全部执行成功，要么全部不执行，不会出现执行一半的情况，其操作组合是不可分割的。
Java中的原子操作
Java中本身的原子操作并不多，只有如下几个
1、基本类型的赋值，int,byte,boolean,short,char,float的赋值操作，float和double，如果在32位JVM虚拟机上运行，很难保证原子性。
2、所有引用reference的赋值操作，不管是32位还是64的虚拟机
3、java.concurrent.Atomic.*包下的所有类的原子操作
只有这几种操作是原子性的。至于long和double由于其变量本身在8个字节，64位，因此在32的虚拟机上的赋值操作是分两步进行的。因此会造成线程安全问题，官方文档对于这种32位错位赋值的变量的时候，建议加上volatile关键字进行修饰。实际开发中，商用版本的JVM其实是已经解决了这个问题。
但是，简单的将各个原子操作组合在一起的操作，并不是原子性的。比如HashMap。
一些面试题
关于JMM中原子性的面试问题，最常见的就是单例模式，针对单例模式我们之前有所总结，但是并没有结合线程的只是进行梳理。
单例模式
单例模式的写法有很多种
1、饿汉式
/**
* autor:liman
* createtime:2021-10-28
* comment:饿汉式单例设计模式（静态常量）
*/
@Slf4j
public class HungarySingleton {
//类加载的时候，JVM会保证线程安全（这里可以用静态代码块初始化，也是一样的）
private final static HungarySingleton INSTANCE = new HungarySingleton();
private HungarySingleton(){
}
public static HungarySingleton getInstance(){
return INSTANCE;
}
}
2、懒汉式（线程不安全的版本）
/**
* autor:liman
* createtime:2021-10-29
* comment:懒汉式 线程不安全
*/
public class LazySingleton {
private static LazySingleton instance;
private LazySingleton(){
}
//在需要获取的时候去实例化，这明显是不满足线程安全要求的
public static LazySingleton getInstance(){
if(null == instance){
instance = new LazySingleton();
}
return instance;
}
}
3、懒汉式（线程安全的版本）
第二种单例模式，明显的不是线程安全的，如果要让其满足线程安全的要求，最简单的方式就是在方法上加上synchronized关键字
/**
* autor:liman
* createtime:2021-10-29
* comment:懒汉式 简单的线程安全
*/
public class LazySingletonSynchronize {
private static LazySingletonSynchronize instance;
private LazySingletonSynchronize(){
}
public synchronized static LazySingletonSynchronize getInstance(){
if(null == instance){
instance = new LazySingletonSynchronize();
}
return instance;
}
}
线程安全了，但是慢，很慢，效率很低。因此我们在此基础上引申出另一种写法，在3的基础上提出优化
4、懒汉式（局部的synchronized）
/**
* autor:liman
* createtime:2021-10-29
* comment:懒汉式 线程不安全
*/
public class LazySingletonSynchronizeLettle {
private static LazySingletonSynchronizeLettle instance;
private LazySingletonSynchronizeLettle(){
}
public synchronized static LazySingletonSynchronizeLettle getInstance(){
if(null == instance){
//方法级别的synchronized影响性能，就将关键的代码用synchronized包围。
synchronized (LazySingletonSynchronizeLettle.class) {
instance = new LazySingletonSynchronizeLettle();
}
}
return instance;
}
}
看上去是对的。但是依旧无法保证完全的单例，因为……if的判断无法保证线程安全。
5、双重检测
/**
* autor:liman
* createtime:2021-10-29
* comment: 单例模式，双重检测
*/
public class SingletonDoubleCheck {
//由于新建对象的操作并不是原子的，而是有三步，而这三步指令，可能被CPU重排序
//这三步重排序可能发生NPE问题
//因此要用volatile修饰，一个是保证可见性，同时防止指令重排序
private static volatile SingletonDoubleCheck instance;
private SingletonDoubleCheck(){
}
public static SingletonDoubleCheck getInstance(){
if(null == instance){
//如果没有这个判断，就等同于直接在方法上加synchronized关键字，效率是很低的。
synchronized (SingletonDoubleCheck.class){
if(null == instance){
//由于多个线程，可能同时到达外层的if语句，并且都执行完null==instance的判断，都发现instance为空，
//后续进入同步代码块，如果没有这一层的if判断，可能会初始化多个对象，因此内部也需要做一个判断
instance = new SingletonDoubleCheck();
}
}
}
return instance;
}
}
这种方式是面试中被问到最多的，关于为什么要加双重检测，少一重行不行。为什么要用volatile来修饰，这个在上述代码注释中都有解释。
6、静态内部类
/**
* autor:liman
* createtime:2021-10-29
* comment:单例模式 静态内部类
*/
public class InnerClassSingleton {
private InnerClassSingleton(){
}
//内部类
private static class SingleInnerInstance{
private static final InnerClassSingleton instance = new InnerClassSingleton();
}
public static InnerClassSingleton getInstance(){
return SingleInnerInstance.instance;
}
}
这种方式其实相当于一种懒汉式的单例模式。根据JVM的规定，在加载类的时候，是不会加载其内部类的，而真正的实例化操作其实在内部类中，也是在调用getInstance方法的时候，才进行加载，而JVM的类加载又保证了线程安全，因此这种方式是线程安全的。同时也属于懒汉式，真正使用中较为推荐。
7、枚举式的单例模式
/**
* autor:liman
* createtime:2021-10-29
* comment:单例模式 枚举类型
*/
public enum EnumSingleton {
INSTANCE;
}
极为简单，这种方式也是大神推荐的。在《Effective Java》中明确表述过，“使用枚举实现单例的方法虽然没有广泛使用，但是单元素的枚举类型已经成为实现单例模式的最佳方法”。
枚举是一种特殊的类，经过反编译之后枚举会被编译成一个final修饰的class，枚举会继承父类Enum，这个父类的实例都是通过static来修饰和定义的，因此枚举的本质经过编译之后，就是一个静态的对象，在我们使用这种单例的时候才会加载，其实也是一种懒加载。同时也会避免反射和反序列化对单例的破坏
针对单例模式其实可考察的点很多，尤其是双重检测，这个考察的最多。
针对使用场景：如果程序一开始要加载的资源太多，那么就应该使用懒加载，饿汉式的单例不适用于对象的创建依赖于配置文件的场景。懒汉式会增加程序的复杂性。
总结
简单梳理了下什么是原子性，对单例模式重新梳理了一下。