简单&易懂的线程安全单例模式

1.前言

单例模式是23种设计模式中最常见的设计模式之一，正确编写单例模式是每个程序员都需要掌握的技术，单例模式也是面试中经常考察的内容，下面以一个面试题开始讲解今天的内容：

手写一个线程安全的单例，并分析为什么是线程安全的？如何防止反射实例化单例对象？

2.单例模式介绍

2.1 定义

数学与逻辑学中，singleton定义为“有且仅有一个元素的集合”。
单例模式最初的定义出现于《设计模式》（艾迪生维斯理, 1994）：“保证一个类仅有一个实例，并提供一个访问它的全局访问点。”
Java中单例模式定义：“一个类有且仅有一个实例，并且自行实例化向整个系统提供。”

2.2 实现要点
单例模式的实现要点包括：

• 构造函数私有化
• 提供一个类方法，用于获取实例
• 注意线程安全

    public class Singleton {
 //构造方法私有化，不让外部通过new创建多个实例
        private Singleton() {
        }
//类的静态私有对象，作为全局唯一访问点
        private static Singleton instance = null;
//提供公有的静态方法供外部调用，返回单例类的唯一实例
        public static  synchronized　Singleton getInstance(){
            if(instance==null){
                   instance=new Singleton();
            }
            return instance;
        }

        
    }

3.线程安全的单例模式

3.1 饿汉模式

public class Singleton {
    
private static Singleton singleton = new Singleton();
    private Singleton() {
    }

    public static Singleton getInstance() {
        return singleton;
    }

}

要理解饿汉模式为什么是线程安全的需要了解JVM的类的加载机制。
Java中的所有类，都需要由类加载器装载到JVM中才能运行。什么时候会触发类的加载呢？当使用new创建实例化对象，读取或者设置一个类的静态字段，调用一个类的静态方法时，JVM会去检查这个类编译得到的class文件是否被已经被加载进来，没有的话就把类加载到虚拟机内存中，并对数据进行校验、转换解析和初始化，最终形成可以被直接使用的Java类型。初始化过程会调用类的构造器方法,方法会为类变量进行赋值，同时虚拟机会保证在多线程环境下被正确地加锁、同步。
结合到饿汉模式：
当我们在外部调用Singleton.getgetInstance()时，因为getgetInstance是类方法，此时虚拟机会去检查Singleton.class是否被加载到虚拟机内存，如果没有，那么就会触发虚拟机的类加载机制，最终进行到初始化阶段时，对类变量singleton 进行赋值，也就是执行

private static Singleton singleton = new Singleton();

同时虚拟机会保证在执行 new Singleton()时线程安全的，最后返回singleton ；如果发现Singleton.class已经被加载过了，则直接返回singleton 。

3.2 双重校验锁（DCL）

public class Singleton {
        private Singleton() {
        }

        private static volatile Singleton instance = null;

        public static Singleton getInstance() {
            if (instance == null) {
                synchronized (Singleton.class) {
                    if (instance == null) {
                        instance = new Singleton();
                    }
                }

            }
            return instance;
        }

    }

1. memory = allocate(); //1：分配对象的内存空间
2. ctorInstance(memory); //2：初始化对象
3. instance = memory; //3：设置instance指向刚分配的内存地址
   但是经过重排序后如下：
4. memory = allocate(); //1：分配对象的内存空间
5. instance = memory; //3：设置instance指向刚分配的内存地址
   //注意，此时对象还没有被初始化！
6. ctorInstance(memory); //2：初始化对象
   将第2步和第3步调换顺序，在单线程情况下不会影响程序执行的结果，但是在多线程情况下就不一样了。线程A执行了instance = memory（这对另一个线程B来说是可见的），此时线程B执行外层 if (instance == null)，发现instance不为空，随即返回，但是得到的却是未被完全初始化的实例，在使用的时候必定会有风险，这正是双重检查锁定的问题所在！

3.3 内部类延迟加载

public class Singleton{
    private Singleton(){}
    private  static class SingletonHolder{
        public final static Singleton instance = new Singleton();
    }

    public static Singleton getInstance(){
        return SingletonHolder.instance;
    }
}