单例模式的五种实现方式及优缺点- 码农充电站

1，饿汉式

饿汉式 的单例实现比较简单，其在类加载的时候，静态实例 instance 就已创建并初始化好了。
代码如下：
public class Singleton { 
  private static final Singleton instance = new Singleton();
  private Singleton () {}
  public static Singleton getInstance() {
    return instance;
饿汉式单例优缺点：
单例对象的创建是线程安全的；
获取单例对象时不需要加锁。
缺点：单例对象的创建，不是延时加载。
一般认为延时加载可以节省内存资源。但是延时加载是不是真正的好，要看实际的应用场景，而不一定所有的应用场景都需要延时加载。
2，懒汉式
与饿汉式对应的是懒汉式，懒汉式为了支持延时加载，将对象的创建延迟到了获取对象的时候，但为了线程安全，不得不为获取对象的操作加锁，这就导致了低性能。
并且这把锁只有在第一次创建对象时有用，而之后每次获取对象，这把锁都是一个累赘（双重检测对此进行了改进）。
代码如下：
public class Singleton { 
  private static final Singleton instance;
  private Singleton () {}
  public static synchronized Singleton getInstance() {    
    if (instance == null) {      
      instance = new Singleton();    
    return instance;  
懒汉式单例优缺点：
对象的创建是线程安全的。
支持延时加载。
缺点：获取对象的操作被加上了锁，影响了并发度。
如果单例对象需要频繁使用，那这个缺点就是无法接受的。
如果单例对象不需要频繁使用，那这个缺点也无伤大雅。
3，双重检测
饿汉式和懒汉式的单例都有缺点，双重检测的实现方式解决了这两者的缺点。
双重检测将懒汉式中的 synchronized 方法改成了 synchronized 代码块。如下：
public class Singleton { 
  private static Singleton instance;
  private Singleton () {}
  public static Singleton getInstance() {
    if (instance == null) {
      synchronized(Singleton.class) { // 注意这里是类级别的锁
        if (instance == null) {       // 这里的检测避免多线程并发时多次创建对象
          instance = new Singleton();
    return instance;
这种实现方式在 Java 1.4 及更早的版本中有些问题，就是指令重排序，可能会导致 Singleton 对象被 new 出来，并且赋值给 instance 之后，还没来得及初始化，就被另一个线程使用了。
要解决这个问题，需要给 instance 成员变量加上 volatile 关键字，从而禁止指令重排序。
而高版本的 Java 已在 JDK 内部解决了这个问题，所以高版本的 Java 不需要关注这个问题。
双重检测单例优点：
对象的创建是线程安全的。
支持延时加载。
获取对象时不需要加锁。
4，静态内部类
用静态内部类的方式实现单例类，利用了Java 静态内部类的特性：
Java 加载外部类的时候，不会创建内部类的实例，只有在外部类使用到内部类的时候才会创建内部类实例。
代码如下：
public class Singleton { 
  private Singleton () {}
  private static class SingletonInner {
    private static final Singleton instance = new Singleton();
  public static Singleton getInstance() {
    return SingletonInner.instance;
SingletonInner 是一个静态内部类，当外部类 Singleton 被加载的时候，并不会创建 SingletonInner 实例对象。
只有当调用 getInstance() 方法时，SingletonInner 才会被加载，这个时候才会创建 instance。instance 的唯一性、创建过程的线程安全性，都由 JVM 来保证。
静态内部类单例优点：
对象的创建是线程安全的。
支持延时加载。
获取对象时不需要加锁。
用枚举来实现单例，是最简单的方式。这种实现方式通过 Java 枚举类型本身的特性，保证了实例创建的线程安全性和实例的唯一性。
public enum Singleton {
  INSTANCE; // 该对象全局唯一
6，多例模式
上面介绍了5 种单例模式的实现方式，下面作为对单例模式的扩展，再来介绍一下多例模式以及线程间唯一的单例模式。先来看下多例模式。
单例模式是指，一个类只能创建一个对象。那么多例模式就是，一个类可以创建多个对象，但是对象个数可以控制。
对于多例模式，我们可以将类的实例都编上号，然后将实例存放在一个 Map 中。
代码如下：
public class MultiInstance {
    // 实例编号
    private long instanceNum;
    // 用于存放实例
    private static final Map<Long, MultiInstance> ins = new HashMap<>();
    static {
        // 存放 3 个实例
        ins.put(1L, new MultiInstance(1));
        ins.put(2L, new MultiInstance(2));
        ins.put(3L, new MultiInstance(3));
    private MultiInstance(long n) {
        this.instanceNum = n;
    public MultiInstance getInstance(long n) {
        return ins.get(n);
实际上，Java 中的枚举就是一个“天然”的多例模式，其中的每一项代表一个实例，如下：
public enum MultiInstance {
    THREE;
7，线程唯一的单例
一般情况下，我们所说的单例的作用范围是进程唯一的，就是在一个进程范围内，一个类只允许创建一个对象，进程内的多个线程之间也是共享同一个实例。
实际上，在Java 中，每个类加载器都定义了一个命名空间。所以我们这里实现的单例是依赖类加载器的，也就是在同一个类加载器中，我们实现的单例就是真正的单例模式。否则如果有多个类加载器，就会有多个单例出现了。一个解决办法是：自行指定类加载器，并且指定同一个类加载器。
那么线程唯一的单例就是，一个实例只能被一个线程拥有，一个进程内的多个线程拥有不同的类实例。
我们同样可以用 Map 来实现，代码如下：
public class ThreadSingleton {
    private static final ConcurrentHashMap<Long, ThreadSingleton> instances
            = new ConcurrentHashMap<>();
    private ThreadSingleton() {}
    public static ThreadSingleton getInstance() {
        Long id = Thread.currentThread().getId();
        instances.putIfAbsent(id, new ThreadSingleton());
        return instances.get(id);
8，使用场景
单例模式可以用来管理一些共享资源，比如数据库连接池，线程池；解决资源冲突问题，比如日志打印。节省内存空间，比如配置信息类。
（本节完。）
推荐阅读：
设计模式之高质量代码
欢迎关注作者公众号，获取更多技术干货。