单例模式

package com.study;

import java.io.ObjectStreamException;
import java.io.Serializable;
import java.util.Objects;

/**
 * 单例模式
 * 1、类的创建模式,创建对象的最优方式，例如spring中管理的bean大部分为单例。
 * 2、单例要素：
 * 全局唯一的对象实例
 * 单例类自己创建唯一的实例(禁止客户端调用创建)
 * 单例类必须对外暴露(提供)获取对象实例的方法
 * 导致单一实例失败问题：
 * 1、调用反射，进行实例化
 * 2、反序列化导致实例不一致
 * 3、线程安全
 */

public class Singleton {
    public static void main(String[] args) {
        SingletonEnum instance = SingletonEnum.SINGLETON;
        instance.doSomething();
    }
}

/**
 * 饿汉 单例模式
 * 即类加载就创建对象(并非调用getInstance时候加载，可能调用其他静态方法导致类加载)，由类加载机制提供线程安全保障
 * 优点：简单安全高效
 * 缺点：不确定对象是否需要使用
 */
class SingletonNormal implements Serializable {
    private static SingletonNormal singleton = new SingletonNormal();

    /**
     * 1、将构造函数设置为私有的避免被new对象，破坏单一实例
     */
    private SingletonNormal() {
        //避免通过反射调用创建对象
        if (!Objects.isNull(singleton)) {
            throw new RuntimeException("实例已存在");
        }
    }

    /**
     * 反序列化时候直接返回singleton实例，不需要重新实例化一个对象实例，避免反序列化造成多个实例
     *
     * @return
     * @throws ObjectStreamException
     */
    private Object readResolve() throws ObjectStreamException {
        return singleton;
    }


    /**
     * 返回实例
     *
     * @return
     */
    public static SingletonNormal getInstance() {
        return singleton;
    }

    /**
     * 如果通过SingletonNormal.test()导致类加载，实例化对象，此时的instance并非真正需要，导致浪费内存
     */
    public static void test() {
        //do ...
    }
}

/**
 * 懒汉  单例模式
 * 用于弥补实例消耗资源，将实例延迟到需要使用的时候创建的方案
 * 优点：仅在通过调用SingletonLazy.getInstance()时候才会创建对象
 * 缺点：因为同步方法，导致效率下降
 */
class SingletonLazy {
    private static SingletonLazy singleton;

    private SingletonLazy() {
        //避免通过反射调用创建对象
        if (!Objects.isNull(singleton)) {
            throw new RuntimeException("实例已存在");
        }
    }

    /**
     * 同步方法避免并发情况下创建多个实例
     *
     * @return
     */
    public static synchronized SingletonLazy getInstance() {
        if (Objects.isNull(singleton)) {
            singleton = new SingletonLazy();
        }
        return singleton;
    }
}

/**
 * 双重校验锁，主要用于弥补高并发下懒汉式的效率低下的方案 （不建议使用）
 * 优点：提升效率
 * 缺点：实现复杂，由于编译器优化等原因可能导致失败
 */
class SingletonDCL {
    private static volatile SingletonDCL singleton = null;//volatile用于解决可见性问题

    private SingletonDCL() {
        //避免通过反射调用创建对象
        if (!Objects.isNull(singleton)) {
            throw new RuntimeException("实例已存在");
        }
    }

    /**
     * 锁住类对象
     *
     * @return
     */
    public static SingletonDCL getInstance() {
        if (Objects.isNull(singleton)) {
            SingletonDCL instance;
            synchronized (SingletonDCL.class) {
                instance = singleton;
                if (Objects.isNull(instance)) {
                    synchronized (SingletonDCL.class) {
                        instance = new SingletonDCL();
                    }
                }
            }
            singleton = instance;
        }
        return singleton;
    }
}

/**
 * 内部类单例模式
 * 通过定义内部类，然后由外表调用内部类的时候加载，由类加载保障安全
 * 优点：高效、延迟加载
 */
class SingletonInner {
    private static SingletonInner singleton;

    private SingletonInner() {
        //避免通过反射调用创建对象
        if (!Objects.isNull(singleton)) {
            throw new RuntimeException("实例已存在");
        }
    }

    /**
     * 执行Singleton.INSTANCE时才会对内部类进行加载
     */
    private static class Singleton {
        private static final SingletonInner INSTANCE = new SingletonInner();
    }

    public static SingletonInner getInstance() {
        return Singleton.INSTANCE;
    }
}

/**
 * 枚举式单例(推荐使用)
 * 由JVM保障安全/反序列化/反射等问题
 * 优点：简单、高效、安全
 * <p>
 * SingletonEnum instance = SingletonEnum.SINGLETON;
 */
enum SingletonEnum {
    SINGLETON;

    public void doSomething() {
        System.out.println("这是最佳的单例实现模式....");
    }
}