1 单例模式的定义

定义：确保某一个类只有一个实例，自行实例化并且向整个系统提供这个实例。
单例模式的通用类图如下所示：

单例模式的通用类图

Singleton称为单例类，通过使用private的构造函数确保了在一个应用中只产生一个实例（应用启动的时候，自行实例化）。

2 单例模式的优点和缺点

单例模式的优点：

1. 提高效率
   当一个对象需要频繁的创建和销毁，并且对象的创建和销毁操作性能无法优化。此时，单例模式可以在应用启动的时候就产生一个实例，永久驻留内存，可以减少系统创建和销毁实例的性能开销，非常明显地提高效率。另外，单例模式在内存中只有一个实例，可以减少内存开支。比如，读取配置等。
2. 避免对资源的多重占用
   例如一个对文件的写操作，由于只有一个实例，避免对同一个资源文件同时写。
3. 在系统设置全局访问点，优化和共享资源访问。

单例模式的缺点：

1. 单例模式一般没有接口，扩展困难。
2. 单例测试对于测试是不利的。在并行开发环境中，如果单例模式没有完成，是不能进行测试的。没有接口，也不能使用mock的方式虚拟一个对象。
3. 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，而不关心是否是单例的。单例模式把单例和业务逻辑融合在一个类中。

3 单例模式的应用场景

在一个系统中，要求一个类有且仅有一个实例，如果出现多个实例就会出现副作用，可以采用单例模式。具体如下：

1. 要求生成唯一序列号的环境。
2. 在整个项目中需要共享一个访问点或者数据。
3. 创建和销毁一个对象需要消耗的资源过多，但是又经常用到。如，要访问IO和数据库连接等。
4. 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（也可以直接声明为static）。
5. 需要频繁的进行创建和销毁的对象。

4 单例模式的最佳实践

单例模式比较简单，也应用广泛。在Spring中，每个Bean默认是单例的，优点是Spring容器可以管理这些Bean的生命周期，决定对象的创建和销毁时机，以及创建和销毁对象时的处理。

5 单例模式常见的实现方式

单例模式的实现可以分为两类：饿汉式(饥汉式)和懒汉式。
饿汉式：在程序启动或单例模式类被加载的时候，单例模式实例就已经被创建。
懒汉式：当程序第一次访问单例模式实例的时候才进行创建。
以上两种方式各有优点。

• 如果单例模式实例在系统中会被频繁用到，饿汉式比较好
  优点：程序启动的时候已经进行了实例化，调用时直接返回实例，速度快，效率高。
  缺点：如果实例使用频率不高或者几乎不用，启动的时候就进行实例化，浪费内存资源。
• 如果单例模式实例在系统中很少用到或者几乎不会用到，懒汉式较好
  优点：如果实例使用频率不高或者几乎不用，启动的时候就不进行实例化，第一次调用的时候进行实例化(lazy-loading)，节约内存资源。
  缺点：单例模式的实例如果被频繁调用，影响效率。

5.1 饿汉式常见实现

5.1.1 推荐的实现(线程安全)

1. 静态变量初始化(最推荐)

public class Singleton(){
     private static Singleton instance = new Singleton();     
     // 私有构造函数
     private Singleton(){
     }

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

2. 静态代码块初始化(类似于1)：

public class Singleton(){
     private static Singleton instance; 
     {
        instance = new Singleton();
     }
     // 私有构造函数
     private Singleton(){
     }

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

3. 枚举类
   单实例枚举类SingletonEnum ：

public enum Singleton {
    /**
     * 实例
     */
    INSTANCE;

    private Singleton() {

    }

    /**
     * 业务方法
     */
    public void doSomething() {
        //TODO 业务代码
    }
}

使用：

public class SingletonDemo {
    public static void main(String[] args) {
        Singleton singleton = Singleton.INSTANCE;
        singleton.doSomething();
    }
}

默认枚举实例的创建是线程安全的，但是在枚举中的其他任何方法由程序员自己负责。如果你正在使用实例方法，那么你需要确保线程安全（如果它影响到其他对象的状态的话）。
传统单例存在的另外一个问题是一旦你实现了序列化接口，那么它们不再保持单例。但是枚举单例，JVM对序列化有保证。
优点：有序列化和线程安全的保证，代码简单。

5.2 懒汉式常见实现

1. 单次判断实例为null
   适合单线程，不适合多线程【线程不安全】。

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

这种写法起到了Lazy Loading的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

2. 同步方法获取实例
   线程安全，但是效率低，不推荐使用。

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

解决上面第1种实现方式的线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。
缺点：效率太低。每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

3. 单次判断实例为null，同步代码块生成实例【不推荐使用】

public class Singleton {
    private static Singleton singleton;
    private Singleton() {}

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

由于第2种实现方式同步效率太低，所以摒弃同步方法，改为同步产生实例化的的代码块。但是这种同步并不能起到线程同步的作用。跟第1种实现方式遇到的情形一致。假如一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

4. 双重检查【推荐使用】

public class Singleton {
    private static volatile Singleton singleton;
    private Singleton() {}

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

Double-Check概念对于多线程开发者来说不会陌生。进行两次 if (singleton == null) 检查，这样就可以保证线程安全了。实例化代码只用执行一次，后面再次访问时，判断 if (singleton == null)，直接return实例化对象。
优点：线程安全；延迟加载；效率较高。

5. 静态内部类【推荐使用】

public class Singleton {
    private Singleton() {}

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }
}

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
优点：避免了线程不安全，延迟加载，效率高。

6 相关知识补充

6.1 关于延迟初始化（lazy loaded）

原则：“除非绝对必要，否则就不要延迟初始化”。
延迟初始化是一把双刃剑，它降低了初始化类或者创建实例的开销，却增加了访问被延迟初始化的域的开销，考虑到延迟初始化的域最终需要初始化的开销以及域的访问开销，延迟初始化实际上降低了性能。

参考

1. JAVA设计模式总结之23种设计模式
2. 设计模式之禅