单例模式的五种实现方式及优缺点

公号：码农充电站pro
主页：https://codeshellme.github.io

当咱们须要使得某个类只能有一个实例时，可使用单例模式。

单例模式（Singleton Design Pattern）保证一个类只能有一个实例，并提供一个全局访问点。

单例模式的实现须要三个必要的条件：

1. 单例类的构造函数必须是私有的，这样才能将类的建立权控制在类的内部，从而使得类的外部不能建立类的实例。
2. 单例类经过一个私有的静态变量来存储其惟一实例。
3. 单例类经过提供一个公开的静态方法，使得外部使用者能够访问类的惟一实例。

注意：
由于单例类的构造函数是私有的，因此单例类不能被继承。

另外，实现单例类时，还须要考虑三个问题：

• 建立单例对象时，是否线程安全。
• 单例对象的建立，是否延时加载。
• 获取单例对象时，是否须要加锁（锁会致使低性能）。

下面介绍五种实现单例模式的方式。

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 来保证。

静态内部类单例优势：

• 对象的建立是线程安全的。
• 支持延时加载。
• 获取对象时不须要加锁。

5，枚举

用枚举来实现单例，是最简单的方式。这种实现方式经过 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 {
    ONE,
    TWO,
    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，使用场景

单例模式能够用来管理一些共享资源，好比数据库链接池，线程池；解决资源冲突问题，好比日志打印。节省内存空间，好比配置信息类。

（本节完。）

---

推荐阅读：

设计模式之高质量代码

---

欢迎关注做者公众号，获取更多技术干货。