原创

设计模式基础(一)——单例模式

对于单例的概念,我觉得没必要解释太多,你一看就能明白。我们所说的单例模式,一般特指JVM进程内的单例,确切的说是限定在ClassLoader范围内的单例。

我们在程序中使用单例模式(Singleton Design Pattern),目的一般是处理资源访问的冲突,或者从业务概念上,有些数据在系统中只应保存一份,那也比较适合设计为单例类,比如配置类、全局流水号生成器等。

一、创建单例对象

我们先来看看有哪几种方式可以实现单例模式。要实现一个单例,无外乎关注下面几个点:

  • 构造函数需要是 private 访问权限的,这样才能避免外部通过 new 创建实例;
  • 考虑对象创建时的线程安全问题;
  • 考虑是否支持延迟加载;
  • 考虑 getInstance() 性能如何(是否加锁)。

1.1 饿汉式

饿汉式的实现方式比较简单。在类加载的时候,instance 静态实例就已经创建并初始化好了,所以,instance 实例的创建过程是线程安全的。

public class IdGenerator { 
  private AtomicLong id = new AtomicLong(0);
  private static final IdGenerator instance = new IdGenerator();

  private IdGenerator() {}

  public static IdGenerator getInstance() {
    return instance;
  }

  public long getId() { 
    return id.incrementAndGet();
  }
}

有人说,这种实现方式不好,因为不支持延迟加载,如果实例占用资源多(比如占用内存多)或初始化耗时长(比如需要加载各种配置文件),提前初始化实例是一种浪费资源的行为,最好的方法应该在用到的时候再去初始化。

我个人反对这种观点,并且认为如果在生产环境确实需要使用单例模式,应该采用饿汉式,理由如下:

  1. 如果初始化耗时长,那我们最好不要等到真正要用它的时候,才去执行这个耗时长的初始化过程,这会影响到系统的性能(比如,在响应客户端接口请求的时候,做这个初始化操作,会导致此请求的响应时间变长,甚至超时);
  2. 如果实例占用资源多,按照 fail-fast 原则,那我们也希望在程序启动时就将这个实例初始化好,如果资源不够,就会在程序启动时报错(比如 Java 中的 PermGen Space OOM),及早发现问题。

1.2 懒汉式

懒汉式相对于饿汉式的优势是支持延迟加载,比如下面这种方式,是采用了双重锁检测的懒汉式,提升了获取单例对象的性能:


public class IdGenerator { 
  private AtomicLong id = new AtomicLong(0);
  private static IdGenerator instance;
  private IdGenerator() {}
  public static IdGenerator getInstance() {
    if (instance == null) {
      synchronized(IdGenerator.class) { // 此处为类级别的锁
        if (instance == null) {
          instance = new IdGenerator();
        }
      }
    }
    return instance;
  }
  public long getId() { 
    return id.incrementAndGet();
  }
}

有人说,上面这种方式可能因为指令重排序,导致 IdGenerator 对象被 new 出来,并且赋值给 instance 之后,还没来得及初始化高版本的 JDK 内部实现中解决了这个问题(解决的方法很简单,只要把对象 new 操作和初始化,就被另一个线程使用了。所以,需要给 instance 成员变量加上 volatile 关键字,禁止指令重排序。

但是,只有很低版本(JDK1.5以下)的 Java 才会有这个问题。高版本的 JDK 内部实现中已经解决了这个问题(把对象 new 操作和初始化操作设计为原子操作,就自然能禁止重排序)。

1.3 静态内部类方式

还有一种方式,是利用 Java 的静态内部类,它有点类似饿汉式,但又能做到延迟加载:

public class IdGenerator { 
  private AtomicLong id = new AtomicLong(0);
  private IdGenerator() {}

  private static class SingletonHolder{
    private static final IdGenerator instance = new IdGenerator();
  }

  public static IdGenerator getInstance() {
    return SingletonHolder.instance;
  }

  public long getId() { 
    return id.incrementAndGet();
  }
}

SingletonHolder 是一个静态内部类,当外部类 IdGenerator 被加载的时候,并不会创建 SingletonHolder 实例对象。只有当调用 getInstance() 方法时,SingletonHolder 才会被加载,这个时候才会创建 instance。

instance 的唯一性、创建过程的线程安全性,都由 JVM 来保证。所以,这种实现方法既保证了线程安全,又能做到延迟加载。

1.4 枚举方式

最后,还有一种很简单的实现方式,就是基于枚举类型来实现。这种实现方式通过 Java 枚举类型本身的特性,保证了对象创建的线程安全性和唯一性:

public enum IdGenerator {
  INSTANCE;
  private AtomicLong id = new AtomicLong(0);

  public long getId() { 
    return id.incrementAndGet();
  }
}

二、线程内单例

我们上述将的单例模式是指ClassLoader内的单例,如何要实现线程内单例呢?所谓线程内单例,指的是线程内唯一,线程间可以不唯一。我们通过一个 HashMap 来存储对象,其中 key 是线程 ID,value 是对象。这样我们就可以做到,不同的线程对应不同的对象,同一个线程只能对应一个对象。

实际上,Java 语言本身提供了 ThreadLocal 工具类,可以更加轻松地实现线程唯一单例。


public class IdGenerator {
  private AtomicLong id = new AtomicLong(0);

  private static final ConcurrentHashMap<Long, IdGenerator> instances
          = new ConcurrentHashMap<>();

  private IdGenerator() {}

  public static IdGenerator getInstance() {
    Long currentThreadId = Thread.currentThread().getId();
    instances.putIfAbsent(currentThreadId, new IdGenerator());
    return instances.get(currentThreadId);
  }

  public long getId() {
    return id.incrementAndGet();
  }
}

三、集群单例

还有一种单例模式,就是所谓的集群内单例。集群相当于多个进程构成的一个集合,“集群唯一”就相当于是进程内唯一、进程间也唯一。也就是说,不同的进程间共享同一个对象,不能创建同一个类的多个对象。

实现集群内单例的核心思路,其实跟利用分布式锁控制访问共享资源是一个道理,只是将创建/销毁单例对象的过程用分布式锁加以控制,保证每次只有一个节点能做创建/销毁的操作:

public class IdGenerator {
  private AtomicLong id = new AtomicLong(0);
  private static IdGenerator instance;
  private static SharedObjectStorage storage = FileSharedObjectStorage();
  private static DistributedLock lock = new DistributedLock();

  private IdGenerator() {}

  public synchronized static IdGenerator getInstance() 
    if (instance == null) {
      lock.lock();
      instance = storage.load(IdGenerator.class);
    }
    return instance;
  }

  public synchroinzed void freeInstance() {
    storage.save(this, IdGeneator.class);
    instance = null; //释放对象
    lock.unlock();
  }

  public long getId() { 
    return id.incrementAndGet();
  }
}

// IdGenerator使用举例
IdGenerator idGeneator = IdGenerator.getInstance();
long id = idGenerator.getId();
IdGenerator.freeInstance();

上面是一段伪代码,我们把单例对象序列化并存储到外部共享存储区(比如文件)。进程在使用这个单例对象的时候,需要先从外部共享存储区中将它读取到内存,并反序列化成对象,然后再使用,使用完成之后还需要再存储回外部共享存储区。多个不同进程之间的访问通过分布式锁来控制。

四、总结

本章,我介绍了设计模式中最为人熟悉的单例模式,生产环境如需使用单例模式,建议采用饿汉式。另外,我们也必须认识到,单例模式存在以下的问题:

  • 单例对 OOP 特性的支持不友好;
  • 单例会隐藏类之间的依赖关系;
  • 单例对代码的扩展性不友好;
  • 单例对代码的可测试性不友好;
  • 单例不支持有参数的构造函数

所以,我们需要根据项目的实际情况,评估是否使用单例模式,建议优先考虑通过工厂模式、IOC 容器(比如 Spring IOC 容器)来保证。

正文到此结束
本文目录