1 为什么要有单例模式

系统中的某些类，只有一个实例很重要。例如：

• 一个系统中可存在多个打印任务，但只能有一个正在工作的任务
• 一个系统只能有一个窗口管理器或文件系统
• 一个系统只能有一个计时工具或ID（序号）生成器

如何保证一个类只有一个实例，且该实例易于访问？

定义一个全局变量可以确保对象随时都可以被访问，但无法避免实例化多个对象。

更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建，并且它可以提供一个访问该实例的方法。这就是单例模式的产生动机。

2 简介

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。

单例模式的关键如下：

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

单例模式是一种对象创建型模式。

优点

• 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例
• 避免对资源的多重占用（比如写文件操作）

缺点

• 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景

• 要求生产唯一序列号
• WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来
• 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。

getInstance() 方法需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。

• 单例模式的 UML 图

分析

单例模式的目的是保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例类拥有一个私有构造器，以防有人通过new直接实例化。

在单例模式的实现过程中，需要注意：

• 单例类的构造器私有
• 提供一个自身的静态私有成员变量；
• 提供一个公有的静态工厂方法
• 检验实例的存在性并实例化自己，然后存储在静态成员变量中，以确保只有一个实例被创建

优点

提供了对唯一实例的受控访问。因为单例类封装了它的唯一实例，所以它可以严格控制客户怎样以及何时访问它，并为设计及开发团队提供了共享的概念

由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象，单例模式无疑可以提高系统的性能。

允许可变数目的实例。我们可以基于单例模式进行扩展，使用与单例控制相似的方法来获得指定个数的对象实例。

缺点

由于单例模式中没有抽象层，因此单例类的扩展困难

单例类的职责过重，在一定程度上违背了“单一职责原则”。

因为单例类既充当了工厂角色，提供了工厂方法，同时又充当了产品角色，包含一些业务方法，将产品的创建和产品的本身的功能融合到一起。

滥用单例将带来一些负面问题，如

为了节省资源将数据库连接池对象设计为单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出

现在很多面向对象语言的运行环境都提供了自动垃圾回收的技术，因此，如果实例化的对象长时间不被利用，系统会认为它是垃圾，会自动销毁并回收资源，下次利用时又将重新实例化，这将导致对象状态的丢失。

适用场景

系统只需要一个实例对象，如

• 系统要求提供一个唯一的序列号生成器
• 需要考虑资源消耗太大而只允许创建一个对象（一些处理器）

客户调用类的单个实例只允许使用一个公共访问点，除了该公共访问点，不能通过其他途径访问该实例。

在一个系统中要求一个类只有一个实例时才应当使用单例模式。反之，若一个类可以有几个实例共存，就需要对单例模式进行改进，使之成为多例模式

应用

一个具有自动编号主键的表可以有多个用户同时使用，但数据库中只能有一个地方分配下一个主键编号，否则会出现主键重复，因此该主键编号生成器必须具备唯一性，可以通过单例模式来实现。

实现方式

1 懒汉式(非线程安全)

最基本的实现方式

不支持多线程。因为没有加锁 synchronized，所以严格意义上并不算单例模式

这种方式 lazy loading 很明显，不要求线程安全，当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。

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

2 懒汉式(线程安全)

为了解决上面的问题，最简单的方法是将整个 getInstance() 方法设为同步（synchronized）

优点：第一次调用才初始化，避免内存浪费。

缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。

虽然做到了线程安全，并解决了多实例的问题，但并不高效。

因为在任何时候只能有一个线程调用 getInstance()

但是同步操作只需要在第一次调用时才被需要，即第一次创建单例实例对象时。

这就引出了双重检验锁。

public class Singleton {
    private static volatile Singleton INSTANCE = null;
    // Private constructor suppresses 
    // default public constructor
    private Singleton() {}
    //thread safe and performance  promote 
    public static  Singleton getInstance() {
        if(INSTANCE == null){
             synchronized(Singleton.class){
                 //when more than two threads run into the first null check same time, to avoid instanced more than one time, it needs to be checked again.
                 if(INSTANCE == null){ 
                     INSTANCE = new Singleton();
                  }
              } 
        }
        return INSTANCE;
    }
  }