【面试系列】6种单例模式（Singleton）实现方法比较

转载文章，文章经 LiteCodes 授权，转载至本博客。

原文地址：【面试系列】6种单例模式（Singleton）实现方法比较

下述代码均省略了 Singleton 类的业务代码段，仅表现作为单例所需的代码部分。

懒汉式

普通懒汉式

public class Singleton {
 
    /** 单例对象 */
    private static Singleton instance;
 
    /**
     * 私有构造方法.
     */
    private Singleton() {
    }
 
    /**
     * 静态方法, 用于获取单利对象.
     * 如果单例对象未创建, 则创建新单例对象, 否则直接返回该对象.
     *
     * @return 单例对象.
     */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

最简单的懒汉式单例，在首次调用  getInstance();  时，会对单例对象进行实例化。

然而，这种方式明显无法在多线程模式下正常工作。当线程并发调用getInstance();  时，由于线程之间没有进行同步，有可能两个线程同时进入 if 条件，导致实例化两次。

线程安全的懒汉式

public class Singleton {
 
    /** 单例对象 */
    private static Singleton instance;
 
    /**
     * 私有构造方法.
     */
    private Singleton() {
    }
 
    /**
     * 静态方法, 用于获取单利对象.
     * 如果单例对象未创建, 则创建新单例对象, 否则直接返回该对象.
     *
     * @return 单例对象.
     */
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

最简单的线程安全的懒汉模式，通过在 getInstance()  方法上添加 synchronized  关键字，保证同一时间仅有一个线程能够执行该代码段，以保证不会出现上面一种方法产生的问题。

然而，这种方法效率很低。每次调用  getInstance()  方法，都将为代码段加锁，同一时间该代码段只能被一个线程访问。然而除了首次调用外，都是不需要同步的，因为 instance  已经被实例化。

Double-Check

public class Singleton {

    /** 单例对象 */
    private static volatile Singleton instance;

    /**
     * 私有构造方法.
     */
    private Singleton() {
    }

    /**
     * 静态方法, 用于获取单利对象.
     * 如果单例对象未创建, 则创建新单例对象, 否则直接返回该对象.
     *
     * @return 单例对象.
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Double-check 即双重校验，该方法是针对上述方法提出的一种改进方案。

在  getInstance()  方法中，通过不加锁判断 instance  是否实例化。如果没有实例化，再进行加锁、实例化过程，以减少在实例化后调用 getInstance()  方法导致的性能损耗。

需注意的是，在代码第4行， instance  的定义处，添加了 volatile  关键字。

为了保证 instance  在多个线程间同步，需要通过 volatile  关键字，指明该变量的值每次需要从主存中直接获取，避免从线程内存中获取，以保证线程间同步。

饿汉式

public class Singleton {
 
    /** 单例对象, 类装载时进行实例化. */
    private static final Singleton singleton = new Singleton();
 
    /**
     * 私有构造方法.
     */
    private Singleton() {
    }
 
    /**
     * 静态方法, 用于获取单利对象.
     *
     * @return 单例对象.
     */
    public static Singleton getInstance() {
        return singleton;
    }
}

饿汉式单例的原理是 ClassLoader  装载类是单线程，通过这种机制避免了线程同步问题。

这种方式虽然避免了线程同步问题，但却有可能带来性能问题。

无论该类是否被使用， ClassLoader  都有可能（也有可能被 ClassLoader  忽略）加载该类并实例化该单例对象。所以在基础类库场景下，这种方法会无故消耗更多的资源。

静态内部类方式

public class Singleton {
 
    /**
     * 私有构造方法.
     */
    private Singleton() {
    }
 
    /**
     * 静态方法, 用于获取单利对象.
     *
     * @return 单例对象.
     */
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
 
    private static class SingletonHolder {
 
        /** 单例对象, 类装载时进行实例化. */
        private static final Singleton instance = new Singleton();
    }
}

这种方法同样利用了 ClassLoader  单线程装载的方式，避免了线程同步问题。然而他和上面一种方法不同的地方在于， instance  对象只有在 SingletonHolder  类被装载的时候才会被实例化。也就是说，只有当 getInstance()  方法调用时，才会被实例化，这样就避免了上述的资源损耗。

枚举方式

public enum Singleton {
    INSTANCE;
}

在《Effective Java》一书中，Joshua Bloch 推荐使用这种方式实现单例模式。这种方式不仅能够避免线程同步问题，而且由于其语法级的约束，JVM 级的支持，保证了其极强的正确性。

如何选择

俗话说，No silver bullet，每一种实现都有其适用的场景。那么，我们如何选择单例的实现方式呢？答案是：取决于你所期望的内容。

如果你的单例类应用频繁，从系统启动后就需要使用，那么，饿汉式可能是一个不错的选择。类加载过程便已经完成了实例化的单例，在之后的调用过程中，无需再进行实例化，也无需害怕因为线程同步导致的性能损耗。

如果你的单例类占用较多资源，并且调用频率较低，那么或许 Double-Check 的懒汉式是一个不错的选择。在单例使用前，并不会被实例化，其所需要的资源也并不会被占用。

如果你的单例类属于某一个类库，或许 Double-Check 的懒汉式是一个不错的选择。一个功能丰富的类库中，并非所有的类都会被使用。然而 ClassLoader 的加载机制，并不一定会将其排除至外。所以，一个懒汉式的单例有可能降低类库使用者的资源损耗。

……

根据你的应用场景，选择一个合适的单例模式吧~