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

公号:码农充电站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 才会被加载,这个时候才会创建 instanceinstance 的唯一性、创建过程的线程安全性,都由 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,使用场景

单例模式可以用来管理一些共享资源,比如数据库连接池,线程池;解决资源冲突问题,比如日志打印。节省内存空间,比如配置信息类。

(本节完。)

推荐阅读:

设计模式之高质量代码

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

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

发表评论

评论已关闭。

相关文章