简单介绍七种单例模式

前言

单例模式相对来说，设计比较简单，但是实现方式多种多样，我们需要从线程安全、高性能、懒加载方面进行评估。

饿汉式

实例代码如下：

public final class Singleton1 {

    private byte[] data = new byte[1024];

    private static Singleton1 instance = new Singleton1();

    private Singleton1() {
        System.out.println("Singleton1 实例化");
    }

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

根据前面可以知道，在类的初始化阶段类变量进行初始化，就是instance变量会被初始化，同时呢1k的空间data也被创建，我们可以写段代码测试下：

public class Test {

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Class<?> aClass1 = Class.forName("fast.cloud.nacos.juc.singleton.Singleton1");
    }
}

运行代码会输出：

Singleton1 实例化

这也说明了Class.forName方法会对类进行初始化

关于这点不懂得可以看看前面的博客，有解释到的，Class.forName 和 ClassLoader的区别

如果一个类属性较少，占用内存也较小，用饿汉式也未尝不可。

总而言之，饿汉式不支持懒加载，可以保证多线程下只被加载一次，性能也比较高。

懒汉式

所谓懒汉式就是当你使用的时候再去创建，代码如下

public final class Singleton2 {
    private byte[] data = new byte[1024];

    private static Singleton2 instance = null;

    private Singleton2() {
        System.out.println("Singleton2 实例化");
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            instance = new Singleton2();
        }
        return instance;
    }
}

这种方式会有一个问题，当两个线程都走在 instance == null时，这个时候会创建两个实例，线程不安全。

懒汉式 + 同步方法

代码如下

public final class Singleton3 {

    private byte[] data = new byte[1024];

    private static Singleton3 instance = null;

    private Singleton3() {
        System.out.println("Singleton3 实例化");
    }

    //加锁，每次只有一个线程获得
    public static synchronized Singleton3 getInstance() {
        if (instance == null) {
            instance = new Singleton3();
        }
        return instance;
    }
}

这种方式的问题在于，synchronized的排他性，同一时刻，只能被一个线程访问，性能低下。

Double-Check

这种方法就是，在初次初始化的时候进行加锁，之后就需要加锁了，提高了效率。

public final class Singleton4 {
    private byte[] data = new byte[1024];

    private static Singleton4 instance = null;

    private Singleton4() {
        System.out.println("Singleton4 实例化");
    }

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

这种会出现空指针异常，我们来逐步分析下：

主要在于singleton = new Singleton4()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
　　1. 给 singleton 分配内存
　　2. 调用 Singleton 的构造函数来初始化成员变量，形成实例
　　3. 将singleton对象指向分配的内存空间（执行完这步 singleton才是非 null了）

在JVM的即时编译器中存在指令重排序的优化。

也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，
被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

解决方案就是加上volatile，就可以了

public final class Singleton5 {

    private byte[] data = new byte[1024];

    /**
     * static 和 volatile 切换，编译器不会报错
     */
    private static volatile Singleton5 instance = null;

    private Singleton5() {
        System.out.println("Singleton5 实例化");
    }

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

这了需要注意
volatile阻止的不是singleton = new Singleton()这句话内部[1-2-3]的指令重排，而是保证了在一个写操作（[1-2-3]）完成之前，
不会调用读操作（if (instance == null)）。

Holder方式

Holder方式借住类加载的特点，同一类加载器只会对同一个类加载一次（这个时候可能被问到类加载器底层如何保证只被加载一次，可以翻翻我前面的博客）

public final class Singleton6 {

    private byte[] data = new byte[1024];


    private static final class Holder {
        private static Singleton6 instance = new Singleton6();
    }

    public static Singleton6 getInstance() {
        return Holder.instance;
    }
}

Holder会在编译的时候被收集到<clinit>方法中，该方法可以保证线程安全。

Singleton6也可以保证懒加载，只有在初次调用getInstance方法时，才会初始化Holder中的实例

枚举方式

利用自动序列化机制，保证了线程的绝对安全

public enum Singleton7 {
    INSTANCE;

    Singleton7() {
        System.out.println("Singleton7 实例化");
    }

    public static void method() {
        //调用该方法，会导致初始化
    }

    public static Singleton7 getInstance() {
        return INSTANCE;
    }
}

这种方法如果调用了外部调用了静态方法也会初始化，可以加上我们的Holder模式

枚举-Holder

public class Singleton8 {

    private byte[] data = new byte[1024];

    private Singleton8() {

    }
    public static void method() {
        //调用该方法，不会导致初始化
    }

    private enum EnumHolder{
        INSTANCE;

        private  Singleton8 instance;
        private EnumHolder() {
            System.out.println("Singleton8 实例化");
            this.instance = new Singleton8();
        }

        public Singleton8 getInstance() {
            return instance;
        }
    }

    public Singleton8 getInstance() {
        return EnumHolder.INSTANCE.getInstance();
    }


}

总结

开发过程中，个人用的比较多的也是Holder模式和枚举模式吧。