一起走进单例模式

一.介绍

单例模式（Singleton Pattern）属于创建型模式，确保一个类仅有一个实例，并提供一个访问这个实例的方法，调用者不需要去实例化类的对象(不需要手动去new)。本文会结合源码加深你对单例模式的理解

二.实现方式

1.大体上分为五种实现方式：饿汉式、懒汉式、双重检查锁、静态内部类、单元素枚举类
2.实现思想基本一致：

• 提供一个唯一的私有实例
• 私有化构造器
• 提供一个公共方法获取私有实例

饿汉式

饿汉式，线程安全，调用效率高，但是不能延迟加载对象实例，不推荐实际开发中使用

/**
 * 饿汉式
 */
public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton(){}

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

在JVM里面这个类只会被实例化一次，实例化的过程由JVM保证线程的安全(JVM以同步的形式来完成类加载的整个过程)

懒汉式

懒汉式，代码简单易读，延迟加载对象实例(懒加载)，但是非线程安全，不能用在多线程环境中，禁止在实际开发中使用

/**
 * 懒汉式
 */
/**
 * 懒汉式
 */
public class SingletonLazy{
    private static SingletonLazy instance;

    private SingletonLazy(){}

    public static SingletonLazy getInstance(){
        //此处存在线程安全问题
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

双重检查锁

双重检查锁是对懒汉式的优化，既具备了懒汉式懒加载的优点，同时增加线程同步和双重检查的机制，但是依赖JVM的底层模型，不同的JVM或者不同厂家的JVM可能会有产生多个实例的情况，不推荐在实际开发中使用

/**
 * 双重检测锁
 */
public class SingletonDoubleCheck {
    /**
     * volatile禁止指令重排
     */
    private volatile static SingletonDoubleCheck instance;

    private SingletonDoubleCheck() {}

    public static SingletonDoubleCheck getInstance() {
        //防止instance不为null的情况下,某一线程持有锁时间过长，导致其他线程长时间等待
        if (instance == null) {
            //synchronized关键字确保线程安全
            synchronized (SingletonDoubleCheck.class) {
                if (instance == null) {
                    instance = new SingletonDoubleCheck();
                }
            }
        }
        return instance;
    }
}

静态内部类

静态内部类是对饿汉式的优化，集成了饿汉式与懒汉式的优点，线程安全、调用效率高、而且支持懒加载，推荐使用。具体内容会在本文的七.饿汉模式的缺点（拓展）中讲到

/**
 * 静态内部类
 */
public class SingletonInnerStatic{
    private SingletonInnerStatic(){}

    public static SingletonInnerStatic getInstance(){
        return SingleHolder.instance;
    }

    private static class SingleHolder{
        //将[提供一个唯一的私有实例的操作]放在了静态内部类
        private static SingletonInnerStatic instance = new SingletonInnerStatic();
    }
}

单元素枚举类

枚举类线程安全，调用效率高，天然预防反射和序列化攻击(会在本文的三.单例模式的破坏与预防中讲到)，但是如果希望在首次初始化对象时运行全局逻辑，这种方式会比较困难，需要根据实际功能场景考虑使用

/**
 * 枚举类
 */
public enum SingletonEnum {
    INSTANCE;
}

我们可以通过反编译SingletonEnum.class文件看出，这种方式也无非就是提供了一个唯一的静态实例

三.单例模式的破坏与预防

1.序列化破坏单例
将单例对象实例以字节流的方式写入到文件中，然后再读取文件字节流，反序列化生成对象实例

/**
 * 序列化破坏单例模式
 */
public class SerializeAttack {
    public static void main(String[] args) throws Exception {
        Singleton instance = Singleton.getInstance();

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("instance"));
        oos.writeObject(instance);
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("instance"));
        Singleton instance1 = (Singleton) ois.readObject();
        ois.close();

        System.out.println(instance ==  instance1); //false
    }
}

2.序列化预防(枚举类天生具有)
Serializable接口的源码中已经给出了解决方案-提供readResolve方法

具体实现

Object readResolve() throws ObjectStreamException{
        return instance;
    }

为什么提供了readResolve方法就能预防序列化破坏？我们看一下readObject方法的源码


为什么枚举类天生预防反序列化？我们再看一下readObject方法的源码

3.反射破坏单例
利用Java的反射机制，修改单例构造函数的访问权限，然后调用构造函数

/**
 * 反射破坏单例模式
 */
public class ReflectAttack {
    public static void main(String[] args) throws Exception {
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        System.out.println(constructor.newInstance() == Singleton.getInstance()); //false
    }
}

4.反射预防(枚举类天生具有，懒汉式无法预防)
具体实现

//修改私有构造器的逻辑
private SingleTon(){
        if(instance != null){
            throw new RuntimeException("prevent reflectAttack");
        }
    }

为什么枚举类天生预防反射攻击？我们来看下newInstance方法的源码

四.使用场景

单例模式适用于在全局范围内(集群/分布式)不需要保证唯一性，只需要在同一个JVM中保持唯一性的场景。我们要合理考虑单例模式的状态的范围是全局还是单JVM

• 配置类读取配置文件
• 单JVM应用中的计数器(例如服务调用次数、网络流量)
• Spring中的bean生成的对象实例默认是单例，但不是使用单例模式实现的

五.在JDK中的应用

单例模式在JDK中最经典的应用莫过于RunTime类(饿汉式)

六.在Spring中的应用

org.springframework.core.ReactiveAdapterRegistry(双重检查锁)

七.饿汉模式的缺点（拓展）

饿汉模式无法控制只有在调用getIntance方法的时候才进行初始化(无法进行懒加载)
1.我们先来看下类加载过程

• 加载二进制数据到内存，生成对应的Class数据结构
• 连接：a.验证，b.准备（给类的静态成员变量赋默认值），c.解析
• 初始化：给类的静态变量赋初值

2.什么时候会触发初始化？
当前类是启动类即main函数所在类、直接进行new操作、访问静态属性、访问静态方法、用反射访问类、初始化一个类的子类等

3.饿汉模式无法控制只有在调用getIntance方法的时候才进行初始化
这里采用访问静态属性的方式举例，并给饿汉式提供一个用于验证的静态变量name

SingleTon.java

/**
 1. 饿汉式
 */
public class SingleTon{
    //静态属性name，仅用于验证
    public static String name;

    private static SingleTon instance = new SingleTon();

    private SingleTon(){
        //控制台打印，仅用于验证
        System.out.println("初始化了");
    }

    public static SingleTon getInstance(){
      return instance;
    }
}

测试类SingletonTest.java

public class SingletonTest {
    public static void main(String[] args) {
        System.out.println(SingleTon.name); //初始化了 null
    }
}

可以看出在未调用getIntance方法的时候，intance实例被初始化了

4.如何弥补这个缺点？
采用静态内部类的方式可以弥补这个缺点，我们来验证一下

SingleTon.java

/**
 * 静态内部类
 */
public class SingleTon{
    //静态属性name，仅用于验证
    public static String name;

    private SingleTon(){
        //控制台打印，仅用于验证
        System.out.println("初始化");
    }

    private static class Inner{
        private static SingleTon instance = new SingleTon();
    }

    public static SingleTon getInstance(){
      return Inner.instance;
    }
}

测试类SingletonTest.java

public class SingletonTest {
    public static void main(String[] args) {
        System.out.println(SingleTon.name); //null
    }
}

可以看出在访问外部静态变量的时候，instance实例没有被初始化

八.单例模式的优缺点

• 优点
  • 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例的时候
  • 单例模式隐藏了实现，封装实现唯一实例的过程，调用者无感知
• 缺点
  • 违背了单一职责原则，单例模式的类既负责实现本身的逻辑，又负责生成和管理唯一的实例