单例模式实现方式的演进过程

什么是单例模式

• 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。
• 单例模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

---

实现思想

单例模式的几种实现方式

1、饿汉式：它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果

public class SingletonDemo {
    /**
     * 在类加载的时候创建对象实例
     */
    private static SingletonDemo instance = new SingletonDemo();
    
    /**
     * 供外部类进行访问以获取对象 instance
     * @return
     */
    public static SingletonDemo getInstance(){
        return instance;
    }
    
    /**
     * 构建一个私有的SingletonDemo构造方法，使得外部类不能访问
     */
    private SingletonDemo(){
    }
}

要点归纳如下：

要点	结论
是否多线程安全	是
是否支持 Lazy 初始化	否
实现难度	容易

这种方式比较常用，但容易产生垃圾对象，因为在类加载时就初始化，浪费了大量的内存。但因为没有加锁，执行效率会提高。

2、懒汉式-线程不安全：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class SingletonLazy {

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

要点归纳如下：

要点	结论
是否多线程安全	否
是否支持 Lazy 初始化	是
实现难度	容易

3、懒汉式-线程安全：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。

public class SingletonLazyBySynchronized {

    private static SingletonLazyBySynchronized instance;
    
    public static synchronized SingletonLazyBySynchronized getInstance(){
        if(instance == null){
            instance = new SingletonLazyBySynchronized();
        }
        return instance;
    }
    
    private SingletonLazyBySynchronized(){
        
    }
}

要点归纳如下：

要点	结论
是否多线程安全	是
是否支持 Lazy 初始化	是
实现难度	容易

优点：这种创建方式是在类第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例线程安全，但加锁会影响效率。一般不会采用这种方式来实现单例

4、双检锁/双重校验锁（DCL，即 double-checked locking）：这种方式采用双锁机制，安全且在多线程情况下能保持高性能

public class SingletonDCL {

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

要点归纳如下：

要点	结论
是否多线程安全	是
是否支持 Lazy 初始化	是
实现难度	较复杂

volatile关键字的使用保证了该对象的可见性，和防止计算机对机器码指令进行的指令重排。这个关键字尤其重要，需深度去剖析。

5、登记式/静态内部类：这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

public class SingletonStatic {
    /**
     * 静态内部类
     */
    private static class SingletonHolder{
        private static final SingletonStatic INSTANCE = new SingletonStatic();
    }
    
    public static final SingletonStatic getInstance(){
        return SingletonHolder.INSTANCE;
    }
    
    private SingletonStatic(){
        
    }
}

要点归纳如下：

要点	结论
是否多线程安全	是
是否支持 Lazy 初始化	是
实现难度	一般

这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程，它跟饿汉式不同的是：饿汉式只要 SingletonDemo 类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是 SingletonStatic 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。

想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面又不希望在 SingletonDemo 类加载时就实例化，因为不能确保 SingletonDemo类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比饿汉式就显得很合理。

单例设计模式总结

• 保证一个类仅有一个实例，并提供一个访问它的全局访问点。
• 单例类必须自己创建自己的唯一实例。
• 单例类必须给所有其他对象提供这一实例。