单例模式（Singleton）

单例模式（Singleton）

​ Singleton模式，主要是一般为了保证自己研发的系统或者软件中只有一个实例，如果使用 Java 的理解就是只有一个对象。因为对象是可以通过 new 的方式来创建，所以为了保证我们的系统里面只有一个对象，必须要做一些约定，然后这些约定和实现，可以称之为单例模式。

​ 在这里，我说个我年轻粗浅理解的一个笑话，我看到单例模式？以为无论如何使用都是单例的，所以我在构思一个软件的时候，想着在另外一个Java应用中，直接调用另外一个Java应用中的单例对象，试图操作另外一个应用。经过几次尝试，我发现不管我怎么设置，另外一个应用就是对我的设置不做任何响应，那时候我觉得委屈极了，怎么就不对呢？现在想想真是一个愚蠢的笑话，当时就没弄明白应用（也可理解为Windows里面的进程）之间是隔离的、独立的，如果想获得另外一个应用的对象，必须通过通信或者文件共享。我说这个笑话主要是想告诉你：假如你也闹了一些类似的笑话，没关系，因为，很多人也闹过。如果你不想再闹这些笑话，只能学习。

​ 单例模式的实现有很多种方式，下面我简单介绍一些常用的写法。

饿汉式

​ 这个模式的好处就是简单、方便，也便于理解，唯一实例是依靠 JVM 来实现。主要的开发源码如下：

/**
 * 饿汉式
 * 类加载到内存以后，直接new一个单例，由JVM保证线程的安全
 * 简单实用
 *
 * 问题：无论用到与否，类都需要装载。
 */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {}

    public static Mgr01 getInstance() {
        return INSTANCE;
    }

    public void out() {
        System.out.println("this is Mgr01");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                Mgr03 mgr03 = Mgr03.getInstance();
                //我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
                System.out.println(mgr03.hashCode());
            }).start();
        }
    }
}

懒汉式

​ 从上面的用例我们可以明显的看到，饿汉式的核心问题，与java的核心 LazyLoading（懒加载）理念不一样，众所周知 Java 是懒加载的，跑性能前，一般都建议先跑30分钟预热，因为java是越跑越快（这个原理，请翻阅JVM相关资料）。所以有人说第一个方式不合理。又提出了LazyLoading 的方案。

/**
 * lazy loading
 * 懒汉式加载
 * 虽然达到了懒加载的目的，但是带来了线程不安全的问题
 */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03() {}

    public static Mgr03 getInstance(){
        if (null == INSTANCE) {
            //假如这里阻塞了，或者
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();

        }
        return INSTANCE;
    }

    public void out () {
        System.out.println("this is Mgr03");
    }

    public static void main(String[] args) {

        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                Mgr03 mgr03 = Mgr03.getInstance();
                //我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
                System.out.println(mgr03.hashCode());
            }).start();
        }
    }
}

双重判空加锁

​ 前面写的 LazyLoading 加载方案，明显存在并发问题，如果并发上来以后，对象可能就不是同一个，所以提出了加锁 synchronized 的方式。如果把 synchronized 加到方法上，固然能解决问题，但是肯定会带来性能问题。所以专家提议把锁加到判断空以后的方法块上面，所以有了双重判空的方式。就有如下代码。

/**
 * lazy loading
 * 懒汉式加载
 * 虽然达到了懒加载的目的，但是带来了线程不安全的问题
 *
 * 双重判空加锁
 */
public class Mgr06 {
    private static Mgr06 INSTANCE;

    private Mgr06() {}

    public static Mgr06 getInstance(){
        if (null == INSTANCE) {
            synchronized (Mgr06.class){
                if (null == INSTANCE) {
                    //假如这里阻塞了，或者
                    try {
                        Thread.sleep(2100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void out () {
        System.out.println("this is Mgr03");
    }

    public static void main(String[] args) {
        System.out.println("Thread start ..........");
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                Mgr06 mgr03 = Mgr06.getInstance();
                //我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
                System.out.println(mgr03.hashCode());
            }).start();
        }
    }
}

静态内部类

​ 这个方式，其实之前我是没接触过的，看完这种方式以后，觉得这个操作真是骚，比双重判空感觉优雅多了。这个方式，其实是利用了Java静态内部类（也是依靠JVM来保证）。因为JVM在加载Java类时，如果没有用到是不会创建静态的内部类。这样又达到了 LazyLoading 的目的，又避免了加锁。加锁一般情况下是不建议加锁的，加锁会浪费系统资源。

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

    private Mgr07() {}

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

    public static Mgr07 getInstance(){
        //假如这里阻塞了，或者
        try {
            Thread.sleep(2100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return Mgr07Holder.INSTANCE;
    }

    public void out () {
        System.out.println("this is Mgr03");
    }

    public static void main(String[] args) {
        System.out.println("Thread start ..........");
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                Mgr07 mgr07 = Mgr07.getInstance();
                //我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
                System.out.println(mgr07.hashCode());
            }).start();
        }
    }
}

枚举单例

​ 面对网络上面的众多关于单例的讨论和方式，让我们的Java创始人之一的某位大神也产生了兴趣，最后终极大招，枚举单例。这种模式可以防止反序列号，大哥出手，一看就有。具体的写法如下。

/**
 *
 * java创始人之一 ，写个了更完美的，这种写法，可以防止反序列化
 * 枚举单例
 */
public enum Mgr08 {

    INSTANCE;

    public void out () {
        System.out.println("this is Mgr03");
    }

    public static void main(String[] args) {
        System.out.println("Thread start ..........");
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                //我们输出线程的hash值，假如是同一个对象，hash值肯定一样。
                System.out.println(Mgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}

​ 最后，单例模式使用范围非常广，几乎所有的开源产品都使用了单例模式，例如一个数据库连接池、一个线程池、读取配置文件等等，Spring 的 IOC 容器里面，默认的对象，都是单例的。所以单例这种设计模式，一定要充分的理解和掌握。