单例设计模式详解

1. 单例概览及场景

单例设计模式的目的只有一个，创建唯一一个实例；主要应用场景是用来限制实例数量，防止资源浪费，我个人觉得一定程度上还能解决一些数据统一问题。

2. 分类及代码说明

根据是否系统一启动就创建实例将他分为饿汉式和懒汉式.

饿汉式：class加载时即实例化，不管用户是否真的需要；

懒汉式：根据用户需要创建实例；如果不需要则不会实例化。

以下代码说明只包含正确的单例测试用例，以下代码皆不存在线程安全问题。

2.1 饿汉式：

2.1.1 饿汉式：采用类的静态变量初始化，保证初始化一次，只有一个实例

package com.mashibing.dp.singleton;

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用！
 * 唯一缺点：不管用到与否，类装载时就完成实例化
 * Class.forName("")
 * （话说你不用的，你装载它干啥）
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {};

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1 == m2);
    }
}

        通常项目中使用此种即可，非常简单，一般场景都适用，这点加载内存影响不大。

2.1.2 饿汉式：枚举实现，保证无法反序列化（因枚举无构造方法，其余单例都可通过反射破坏单例原则）

package com.mashibing.dp.singleton;

/**
 * 不仅可以解决线程同步，还可以防止反序列化。
 */
public enum Mgr08 {

    INSTANCE;

    public void m() {}

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }

}

2.2 懒汉式：

2.2.1 懒汉式：使用锁机制控制

package com.mashibing.dp.singleton;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

       此种方案引入锁机制，还需加上volatile，较为复杂，但是功能上比饿汉式强一些，为了节省内存或某些特定场景依旧推荐。

2.2.2 懒汉式：依靠class的加载机制实现。jvm虚拟机在加载class时，不会加载其内部类，只会在使用时加载。

package com.mashibing.dp.singleton;

/**
 * 静态内部类方式
 * JVM保证单例
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 */
public class Mgr07 {

    private Mgr07() {
    }

    private static class Mgr07Holder {
        private final static Mgr07 INSTANCE = new Mgr07();
    }

    public static Mgr07 getInstance() {
        return Mgr07Holder.INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr07.getInstance().hashCode());
            }).start();
        }
    }


}

    此种方案借助JVm的类加载规则，同样实现了懒汉式，并且未引入锁，此种方案同样值得推荐。

3.总结

一般用的最多的方式即为饿汉式的2.1.1，基本可以满足百分之九十场景；其余用户可根据具体场景选用，在我看来，能实现功能的情况下，简单就是第一准则。