[关闭]
@Tyhj 2019-01-29T02:57:04.000000Z 字数 2156 阅读 414

单例模式

设计模式


单例的定义

确保某一个类只有一个实例,而且自行实例化并且向整个系统提供整个实例。

使用场景

确保一个类有且只有一个对象,避免产生多个对象消耗资源,比如访问IO和数据库等资源的时候就需要使用单例

实现方式

最简单的实现,线程不安全

保证只有一个对象,那么构造方法肯定得是私有的,通过一个静态方法获取对象,当对象为空的时候初始化对象,否则直接返回,需要用到的时候再去初始化,属于懒加载模式。

  1. public class Singleton {
  2. private static Singleton singleton;
  3. private Singleton() {
  4. }
  5. public static Singleton getInstance() {
  6. if (singleton == null) {
  7. singleton = new Singleton();
  8. }
  9. return singleton;
  10. }
  11. }

缺点就是当多线程调用getInstance的时候可能会初始化多个对象,所以这个方法不可取

懒汉式,线程安全

那么可以加上有个同步来试试

  1. public synchronized static Singleton getInstance() {
  2. if (singleton == null) {
  3. singleton = new Singleton();
  4. }
  5. return singleton;
  6. }

其实这样是OK的,当执行方法的时候,在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码块以后才能执行该代码块;但是有个小问题,这样效率比较低;所以可以稍微优化一下,把同步放到了判断为空以后

  1. public static Singleton getInstance() {
  2. if (singleton == null) {
  3. synchronized (Singleton.class) {
  4. singleton = new Singleton();
  5. }
  6. }
  7. return singleton;
  8. }

这个样子看起来是可以的,但是还是有一个小问题,不容易被发现;就是如果一个线程执行到singleton = new Singleton()这一步的时候(不属于原子操作),这句代码包括了三步,

  • singleton分配内存,
  • 调用 Singleton 的构造函数来初始化成员变量,
  • 将instance对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

在 JVM 的即时编译器中存在指令重排序的优化,上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2,所以如果直接执行了1-3-2,这时候刚好另一个线程执行进来,执行if (singleton == null)代码,判断不为空然后拿着对象去使用,但其实变量还没有初始化,程序就会出错;

双重检验锁模式

我们可以将singleton变量声明成volatile,它有一个特性就是禁止指令重排序优化,这样就没有问题了;

  1. public class Singleton {
  2. private static volatile Singleton singleton;
  3. private Singleton() {}
  4. public static Singleton getInstance() {
  5. if (singleton == null) {
  6. synchronized (Singleton.class) {
  7. singleton = new Singleton();
  8. }
  9. }
  10. return singleton;
  11. }
  12. }

饿汉式 static final field

但是有没有发现上面这种方法写起来有点麻烦;所以简单点,可以直接使用静态变量

  1. public class Singleton {
  2. private final static Singleton singleton = new Singleton();
  3. private Singleton() {}
  4. public static Singleton getInstance() {
  5. return singleton;
  6. }
  7. }

这种写法其实是OK的,可以使用的,缺点在于不是一种懒加载模式,加载类后就被初始化,即使可能用不到;而且在有些场景,比如需要传入参数时候,就不适用了

静态内部类 static nested class

我比较喜欢这种方法,感觉是比较好的,写起来也比较方便,这种方法也是《Effective Java》上所推荐的

  1. public class Singleton {
  2. private Singleton() {}
  3. private static class SingletonHolder {
  4. private static final Singleton singleton = new Singleton();
  5. }
  6. public static Singleton getInstance() {
  7. return SingletonHolder.singleton;
  8. }
  9. }

枚举 Enum

枚举也是一种很好的方法,很简单,而且还能防止反序列化导致重新创建新的对象;但是好像一般也没什么人用,我觉得还OK

  1. public enum Singleton {
  2. SINGLETON;
  3. public static void main(String[] args){
  4. Singleton singleton=Singleton.SINGLETON;
  5. }
  6. }

总结

大概也就这几种常见的单例写法,其实就是为了确保一个类有且只有一个对象,自己觉得哪种合适,哪种方便就使用哪种好了;

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注