(转载) 什么是单例模式?

最近找实习的时候,经常被问到什么是单例模式,能不能手写一个单例模式。。。虽然我面试的都是机器学习岗。所以,痛定思痛,今天来整理总结一下什么是单例模式,这里主要是整理一下耗子叔曾经写过的一篇文章 —- 深入浅出单实例SINGLETON设计模式

单例模式的目的是想在整个系统中只能出现一个类的实例。

普通的 Singleton 版本

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

Singleton 的几个特点:

  1. 私有(private)的构造函数,表明这个类是不可能形成实例了。这主要是怕这个类会有多个实例。
  2. 即然这个类是不可能形成实例,那么,我们需要一个静态的方式让其形成实例:getInstance()。注意这个方法是在new自己,因为其可以访问私有的构造函数,所以他是可以保证实例被创建出来的。
  3. 在 getInstance()中,先做判断是否已形成实例,如果已形成则直接返回,否则创建实例。
  4. 所形成的实例保存在自己类中的私有成员中。
  5. 我们取实例时,只需要使用 Singleton.getInstance() 就行了。

改进下的 Singleton

上面这个例子因为是全局性的实例,所以,在多线程情况下,所有的全局共享的东西都会变得非常危险,如果在多线程情况下同时调用 gerInstance() 的话,那么,可能会有多个进程同时通过 singleton == null 的条件检查,于是多个实例就创建出来,并且可能造成内存泄露问题。所以改进版本如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
private static Singleton singleton = null;
private Singleton() { }
public static Single getInstance() {
if (singleton == null) {
synchronized (Singleton.class) {
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
  1. 第一个条件是说,如果实例创建了,那就不需要同步了,直接返回就好了。
  2. 不然,我们就开始同步线程。
  3. 第二个条件是说,如果被同步的线程中,有一个线程创建了对象,那么别的线程就不用再创建了。

但是, single = new Singleton() 这句,并非是一个原子操作。事实上,在 JVM 中,这句话大概做了下面 3 件事情。

  1. 给 singleton 分配内存
  2. 调用 Singleton 的构造函数来初始化成员变量,形成实例
  3. 将 singleton 对象指向分配的内存空间

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者,则在 3 执行完毕、2 未执行之前,被线程二抢占了,这时 instance 已经是非 null 了(但却没有初始化),所以线程二会直接返回 instance,然后使用,然后便会报错。

因此,修改的方法是把 singleton 声明成 volatile 就可以了。

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

使用 volatile 有两个功用:

  1. 这个变量不会在多个线程中存在复本,直接从内存读取。
  2. 这个关键字会禁止指令重排序优化。也就是说,在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。

Singleton 的简化版本

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

这种方法非常简单,因为单例的实例被声明成 static 和 final 变量了,在第一次加载类到内存中时就会初始化,所以创建实例本身是线程安全的。

但是,这种方法的最大问题是,当这个类被加载的时候,new Singleton() 这句话就会被执行,就算是 getInstance() 没有被调用,类也被初始化了。

于是,这个可能会与我们想要的行为不一样,比如,我的类的构造函数中,有一些事可能需要依赖于别的类干的一些事(比如某个配置文件,或是某个被其它类创建的资源),我们希望他能在我第一次getInstance()时才被真正的创建。这样,我们可以控制真正的类创建的时刻,而不是把类的创建委托给了类装载器。

于是,

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

上面这种方式,仍然使用 JVM 本身机制保证了线程安全问题;由于 SingletonHolder 是私有的,除了 getInstance() 之外没有办法访问它,因此它只有在 getInstance() 被调用时才会真正创建;同时读取实例的时候不会进行同步,没有性能缺陷;也不依赖 JDK 版本。