背景

最近学习了JVM之后，总感觉知识掌握不够深，所以想通过分析经典的【懒汉式单例】来加深一下理解。（主要是【静态内部类】实现单例的方式）。
如果小白想理解单例的话，也能看我这篇文章。我也通过了【前置知识】跟【普通懒汉式】、【双检锁懒汉】、【静态内部类】懒汉给大家分析了一下他们的线程安全性。但是，我这边没有完整的演进【懒汉式单例】历程。所以，会缺少思维上的递进。不过，我在最后的【感谢】名单里，提供了一个完整的【懒汉式单例演进】的链接，建议可以结合这个文章一起学习。

前置知识

类加载运行全过程

当我们用java命令运行某个类的main函数启动程序时，首先需要通过类加载器把主类加载到JVM。

package com.tuling.jvm;public class Math {public static final int initData = 666;public static User user = new User();public int compute() {  //一个方法对应一块栈帧内存区域int a = 1;int b = 2;int c = (a + b) * 10;return c;}public static void main(String[] args) {Math math = new Math();math.compute();}
}

通过Java命令执行代码的大体流程如下：
在这里插入图片描述
其中loadClass的类加载过程有如下几步：
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口
验证：校验字节码文件的正确性
准备：给类的静态变量分配内存，并赋予默认值
解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用，下节课会讲到动态链接
初始化：对类的静态变量初始化为指定的值，执行静态代码块

总结一下，上面说的加载 >> 验证 >> 准备 >> 解析 >> 初始化过程是由JVM帮我们进行的，所以，对我们程序员来说，【天生】就具备线程安全性（这个由JVM帮我们保证，无需我们关心）。

单例模式的实现方式

单例模式，是我们Java中很常见的一个设计模式。所以有这么一种说法：遇事不决，单例解决。
Java单例通常有2种，分别为：饿汉式、懒汉式

一、饿汉式

基本介绍

饿汉式（Eager Initialization，急切的初始化），在类加载时就创建单例实例，并在需要时直接返回该实例。这种方式的实现是线程安全的，因为在类加载过程中实例已经创建好了。

源码

public class SingletonTest {private static final SingletonTest me = new SingletonTest();public static SingletonTest me() {return me;}public static void main(String[] args) {System.out.println(SingletonTest.me());System.out.println(SingletonTest.me());System.out.println(SingletonTest.me());}
//    系统输出如下：
//    org.tuling.juc.singleton.SingletonTest@12a3a380
//    org.tuling.juc.singleton.SingletonTest@12a3a380
//    org.tuling.juc.singleton.SingletonTest@12a3a380
}

分析

因为单例对象SingletonTest 是静态成员变量，所以，在JVM类加载过程中==（加载-》验证-》准备-》解析-》初始化）==的【解析】阶段已经被JVM初始化了，所以，由JVM保证了线程安全性。

二、懒汉式

基本介绍

懒汉式（Lazy Initialization），在首次调用时创建单例实例，存在线程安全问题。如果多个线程同时进入判断条件，可能会创建多个实例。

源码

public class SingletonTest {private static SingletonTest me;public static SingletonTest me() {if(me == null) {me = new SingletonTest();}return me;}public static void main(String[] args) {for (int i = 0; i < 10; i++) {new Thread(()->{System.out.println(SingletonTest.me());}).start();}}
}

输出结果如下
在这里插入图片描述

分析

为什么上面这段代码不是线程安全的呢？我们举一个极端的例子，如下图所示：
在这里插入图片描述
在没有锁机制的存在情况下，多线程环境里面可能会出现上述的并发执行情况。在线程1判断完me == null之后，即将开始执行new之前，线程2也刚好在判断me == null，这是因为线程1还没有执行new操作，所以线程2判断肯定是null的，于是也开始new。这就是线程安全问题所在。
（PS：小白们一定要理解上面这个图。虽然很简单，但是说它是你们迈向，或者培养【并发意识】的启蒙都不为过。）

改进

为了解决上面的问题，大牛们进行了改进，使用了【双检锁+volatile】机制，【双检锁】，即：双重检查锁。代码如下：

public class SingletonTest {private static volatile SingletonTest me;public static SingletonTest me() {if(me == null) {synchronized (SingletonTest.class) {if (me == null) {me = new SingletonTest();}}}return me;}
}

上面的改进，关键点如下：

使用了volatile关键字修饰单例对象me
在获取单例对象的时候，判断了两次if(me == null)
第二次判断if(me == null)之前，先加了锁

第二、三点我就不说了，大家可以看看最下面【感谢】的友链。这里重点说说第一点。
估计小白会很难理解，为什么一定要volatile关键字修饰，不用可以吗？答案是：不可以。因为，volatile能禁止重排序。什么是【重排序呢】？说的简单点，就是JVM，甚至是CPU为了性能，可能会在不改变语义的情况下修改我们的代码执行顺序。比如，当我们new SingletonTest()的时候，你以为只有一步操作，实际上，它有3步，如下：

memory = allocate(); // 1.分配对象内存空间
instance(memory); // 2.初始化对象
instance = memory; // 3.设置instance指向刚分配的内存地址，此时instance！=null

但事实上，经过重排序之后可能会变成下面的执行顺序：

memory = allocate(); // 1.分配对象内存空间
instance = memory; // 3.设置instance指向刚分配的内存地址，此时instance！=null
instance(memory); // 2.初始化对象

然后大家再用上面的【并发启蒙】意识，自己画个图看下，还能线程安全吗？
所以，需要使用volatile关键字，告诉底层JVM或者CPU，不要帮我重排序这个对象！于是就避免了上面的并发线程安全问题了。

三、懒汉式单例终极解决方案（静态内部类）（推荐使用方案）

基本介绍

这里通过利用JVM类加载【天生线程安全】的特性，来帮助实现【懒汉式】的单例。如何做到呢？答案是【静态内部类】。

源码

public class SingletonTest {/** 单例对象，可以直接调用配置属性  */private static class Holder {private static SingletonTest me = new SingletonTest();}public static SingletonTest me() {return Holder.me;}public static void main(String[] args) {int threadCount = 10000;for (int i = 0; i < threadCount; i++) {new Thread(()->{System.out.println(SingletonTest.me());}).start();}}
}