1 定义

有时候为了节约系统资源，需要确保系统中某个类只有唯一一个实例，当这个实例创建成功之后，无法再创建一个同类型的其他对象，所有的操作都只能基于这个唯一的实例，这是单例模式的动机所在。

单例模式（Singleton Pattern）：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。单例模式是一种对象创建型模式。

2 要点

• 某个类只能有一个实例
• 它必须自行创建这个实例
• 它必须自行向整个系统提供这个实例

3 通用步骤

一般来说把一个普通类重构为一个单例类需要以下三步：

• 构造函数私有化：也就是禁止外部直接使用new等创建对象
• 定义一个静态类成员保存实例
• 增加一个类似 getInstance()的公有静态方法来获取实例

因此一般来说单例模式的结构图如下：

4 实例

下面以一个简化的负载均衡器设计进行单例模式的说明。

某个软件需要使用一个全局唯一的负载均衡器，设计如下：

public class LoadBalancer
{
    private static LoadBalancer instance = null;

    private LoadBalancer(){}

    public static LoadBalancer getInstance()
    {
        return instance == null ? instance = new LoadBalancer() : instance;
    }

    public static void main(String[] args) {
        LoadBalancer balancer1 = LoadBalancer.getInstance();
        LoadBalancer balancer2 = LoadBalancer.getInstance();
        System.out.println(balancer1 == balancer2);
    }
}

这是最简单的单例类的设计，获取实例时仅仅判断是否为null，没有考虑到线程问题。也就是说，多个线程同时获取实例时，还是会产生多个实例，一般来说，常见的解决方式如下：

• 饿汉式单例
• 懒汉式单例
• IoDH

5 饿汉式单例

饿汉式单例就是在普通的单例类基础上，在定义静态变量时就直接实例化，因此在类加载的时候就已经创建了单例对象，而且在获取实例时不需要进行判空操作直接返回实例即可：

public class LoadBalancer
{
    private static LoadBalancer instance = new LoadBalancer();

    private LoadBalancer(){}

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

当类被加载时，静态变量instance被初始化，类的私有构造方法将被调用，单例类的唯一实例将被创建。

6 懒汉式单例

懒汉式单例在类加载时不进行初始化，在需要的时候再初始化，加载实例，同时为了避免多个线程同时调用getInstance()，可以加上synchronized：

public class LoadBalancer
{
    private static LoadBalancer instance = null;

    private LoadBalancer(){}

    synchronized public static LoadBalancer getInstance()
    {
        return instance == null ? instance = new LoadBalancer() : instance;
    }
}

这种技术又叫延迟加载技术，尽管解决了多个线程同时访问的问题，但是每次调用时都需要进行线程锁定判断，这样会降低效率。事实上，单例的核心在于instance = new LoadBalancer()，因此只需要锁定这行代码，优化如下：

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

但是实际情况中还是有可能出现多个实例，因为如果A和B两个线程同时调用getInstance()，都通过了if(instance == null)的判断，假设线程A先获得锁，创建实例后，A释放锁，接着B获取锁，再次创建了一个实例，这样还是导致产生多个单例对象，因此，通常采用一种叫“双重检查锁定”的方式来确保不会产生多个实例：

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

需要注意的是要使用volatile修饰变量，volatile可以保证可见性以及有序性。

7 饿汉式与懒汉式的比较

• 饿汉式单例在类加载时就已经初始化，优点在于无需考虑多线程访问问题，可以确保实例的唯一性
• 从调用速度方面来说会优于懒汉式单例，因为在类加载时就已经被创建
• 从资源利用效率来说饿汉式单例会劣于懒汉式，因为无论是否需要使用都会加载单例对象，而且由于加载时需要创建实例会导致类加载时间变长
• 懒汉式单例实现了延迟加载，无须一直占用系统资源
• 懒汉式单例需要处理多线程并发访问问题，需要双重检查锁定，且通常来说初始化过程需要较长时间，会增大多个线程同时首次调用的几率，这会导致系统性能受一定影响

8 IoDH

为了克服饿汉式单例不能延迟加载以及懒汉式单例的线程安全控制繁琐问题，可以使用一种叫Initialization on Demand Holder（IoDH）的技术。实现IoDH时，需在单例类增加一个静态内部类，在该内部类中创建单例对象，再将该单例对象通过getInstance()方法返回给外部使用，代码如下：

public class LoadBalancer
{
    private LoadBalancer(){}
    private static class HolderClass
    {
        private static final LoadBalancer instance = new LoadBalancer();
    }

    public static LoadBalancer getInstance()
    {
        return HolderClass.instance;
    }
}

由于单例对象没有作为LoadBalancer的成员变量直接实例化，因此类加载时不会实例化instance。首次调用getInstance()时，会初始化instance，由JVM保证线程安全性，确保只能被初始化一次。另外相比起懒汉式单例，getInstance()没有线程锁定，因此性能不会有任何影响。

通过IoDH既可以实现延迟加载，又可以保证线程安全，不影响系统性能，但是缺点是与编程语言本身的特性相关，很多面向对象语言不支持IoDH。另外，还可能引发NoClassDefFoundError（当初始化失败时），例子可以见原文。

9 枚举实现单例（推荐）

其中，无论是饿汉式，还是懒汉式，还是IoDH，都有或多或少的问题，并且还可以通过反射以及序列化/反序列化方式去“强制”生成多个单例，有没有更优雅的解决方案呢？

有！答案就是枚举。

代码如下：

public class Test
{
    public static void main(String[] args) {
        LoadBalancer balancer1 = SingletonEnum.INSTANCE.getInstance();
        LoadBalancer balancer2 = SingletonEnum.INSTANCE.getInstance();
        System.out.println(balancer1 == balancer2);
    }
}

class LoadBalancer
{
}

enum SingletonEnum
{
    INSTANCE;
    private LoadBalancer instance = null;
    private SingletonEnum()
    {
        instance = new LoadBalancer();
    }

    public LoadBalancer getInstance()
    {
        return instance;
    }
}

10 总结

优点

单例模式主要优点如下：

• 单例模式提供了对唯一实例的受控访问，可以严格控制客户怎样以及何时访问它
• 由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式可以提高系统性能
• 可以扩展成多例类

缺点

单例模式主要缺点如下：

• 没有抽象层，扩展困难
• 单例类职责过重，一定程度上违反了单一权责原则，因为既提供了业务方法，也提供了创建对象方法，将对象创建以及对象本身的功能耦合在一起
• 很多语言提供了GC机制，实例化的对象长时间不使用将被回收，下次使用需要重新实例化，这回导致共享的单例对象状态丢失

使用场景

• 系统需要一个实例对象
• 客户调用类的单个实例只允许使用一个公共访问点

思维导图总结