设计模式-并不简单的单例模式

2017-09-21  本文已影响0人  ymjkMaster

概述

有时候我们在写程序的时候，我们希望在全局共用一个对象。比如一个负责读取全局配置文件的类A，读取一次配置文件之后，使用单例模式，我们可以得到一个全局唯一的对象a，其他对象读取配置时就不用重复实例化类A，并重复读取配置文件了。
总之，单例模式保证了某个类全局只存在一个实例。

单例模式的实现一般可以分为以下几类

下面简要介绍上述实现方法

懒汉式（非线程安全）

先上代码

/**
 * 懒汉模式，非线程安全
 */
public class SingleTon() {
  private static SingleTon instance;
  private SingleTon() {}

  public static SingleTon getInstance() {
    if (instance == null) {
      instance = new SingleTon();
    }
    return instance;
  }
}

懒汉模式只所以叫懒汉，是因为他使用了“惰性加载（Lazy Initialization）”的思想(好吧，这是我瞎猜的)
为了防止单例类被其他类new出来，我们将单例类的构造函数设为private。在单线程模式下，这个单例是可用的，但是一旦在多线程的情况下，可能会有多个线程进入if语句，导致单例产生多个实例。

总之，该实现方式使用了惰性加载技术，但是非线程安全，不推荐使用。

懒汉式（线程安全）

在之前的基础上，为了保证懒汉式单例模式的线程安全，我们利用Java的synchronized关键字保证其线程安全。其代码如下。

public class SingleTon() {
  private static SingleTon instance;
  private SingleTon() {}
  public static synchronized getInstance() {
    if (instance == null) {
      instance = new SingleTon();
    }
    return instance;
  }
}

使用了synchronized关键字对getInstance方法修饰后，我们保证了懒汉式的线程安全性。但是该模式存在一个致命的问题，那就是性能问题。

假设SingleTon类的instance已经被实例化了，如果有多个线程调用getInstance时，只有一个线程能获得锁，其他线程都不得不等待，这会影响系统的性能。

总之，线程安全的懒汉式同样使用了惰性加载技术，并且是线程安全的，但是并发性能并不是很好。那么怎么解决这个问题，并能保证线程安全和使用懒加载呢？答案是“双重检验锁”。

双重检验锁

先看代码

public class SingleTon {
  private static SingleTon instance;
  public static SingleTon getInstance() {
    if (instance == null) {
      synchronized(SingleTon.class) {
        if (instance == null) {
          instance = new SingleTon();
        }
      }
    }
    return instance;
  }
}

如上面代码所示，如果第一次检查instance不为null，那么就不需要执行下面的加锁和初始化操作。因此可以大幅降低synchronized带来的性能开销。

看似这段代码可以很好的实现单例模式了，但是这段代码有一个隐藏的BUG。原因在instance = new SingleTon()这句话，因为JVM在执行这句代码的时候，大概进行了以下3个步骤：

  1. 为SingleTon分配内存。
  2. 调用SingleTon的构造函数进行初始化。
  3. 将instance指针指向分配好的地址。
    理想执行顺序是1->2->3，之前的代码不会有问题。然而由于某些JIT编译器存在指令重排序，可能会出现1->3->2的指令执行顺序，这时可能会导致线程1执行完3以后，另外一个线程抢占使用instance，那么就会出现错误。

解决这个问题的办法很简单，只需要将 instance 变量声明成 volatile 就可以了。
volatileu关键字有两个功能：

  1. 保证变量的内存可见性
  2. 局部阻止重排序的发生
    这里我们用到了第二个功能，保证了单例模式的正常实现。修改后的代码如下：
public class SingleTon {
  private volatile static SingleTon instance;
  public static SingleTon getInstance() {
    if (instance == null) {
      synchronized(SingleTon.class) {
        if (instance == null) {
          instance = new SingleTon();
        }
      }
    }
    return instance;
  }
}

通过上面的代码，我们就可以愉快地使用单例模式了。这是一种比较线程安全且用到了惰性加载技术的单例模式实现方法。

饿汉模式

这里介绍另外一种不适用惰性加载技术的单例模式实现方法，不使用惰性加载之后，代码也变得简洁了许多。代码如下。

public class SingleTon() {
  private static final SingleTon instance = new SingleTon();
  private SingleTon() {}
  public static SingleTon getInstance() {
    return instance;
  }
}

可以看到，这种单例模式在类加载期间就会初始化instance实例，JVM会保证多个线程初始化一个类的时候只有一个类执行，所以我们不用担心线程安全问题。

静态内部类方法

代码如下

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;
    }  
}

原理同饿汉式类似，不在啰嗦。

枚举类方法

Java自身的枚举类能够保证全局只存在有限个实例，并能线程安全的访问。代码也非常简洁。

public enum SingleTon() {
  INSTANCE;
}

总结

本文，我们介绍了6种单例模式的实现方法，我们可以根据不同的业务场景来实现单例模式。当然，实现单例模式的时候我们不光关注惰性加载和线程安全，序列化反序列化问题也是单例模式的一个问题，且看下回分解。

上一篇下一篇

猜你喜欢

热点阅读