你真的会写单例模式吗

作者:DeppWang原文地址

又一篇一抓一大把的博文,可是你真的的搞懂了吗?点开看看,事后,你也来一篇。。。

人生在世,谁不面试。单例模式:一个搞懂不加分,不搞懂减分的知识点

img

单例模式是面试中非常喜欢问的了,我们往往自认为已经完全理解了,没什么问题了。但要把它手写出来的时候,可能出现各种小错误,下面是我总结的快速准确的写出单例模式的方法。

单例模式有各种写法,什么「双重检锁法」、什么「饿汉式」、什么「饱汉式」,总是记不住、分不清。这就对了,人的记忆力是有限的,我们应该记的是最基本的单例模式怎么写。

单例模式:一个类有且只能有一个对象(实例)。单例模式的 3 个要点:

  1. 外部不能通过 new 关键字(构造函数)的方式新建实例,所以构造函数为私有:private Singleton(){}
  2. 只能通过类方法获取实例,所以获取实例的方法为公有、且为静态:public static Singleton getInstance()
  3. 实例只能有一个,那只能作为类变量的「数据」,类变量为静态 (另一种记忆:静态方法只能使用静态变量):private static Singleton instance

一、最基础、最简单的写法

类加载的时候就新建实例

public class Singleton {
private static Singleton instance = new Singleton();

private Singleton() {
}

public static Singleton getInstance() {
return instance;
}

public void show(){
System.out.println("Singleon using static initialization in Java");
}
}

// Here is how to access this Singleton class
Singleton.getInstance().show();

当执行 Singleton.getInstance() 时,类加载器加载 Singleton.class 进虚拟机,虚拟机在方法区(元数据区)为类变量分配一块内存,并赋值为空。再执行类构造器 <client>() 方法,新建实例指向类变量 instance。这个过程在类加载阶段执行,并由虚拟机保证线程安全。所以执行 getInstance() 前,实例就已经存在,所以 getInstance() 是线程安全的。

很多博文说 instance 还需要声明为 final,其实不用。final 的作用在于不可变,使引用 instance 不能指向另一个实例,保证变量可见性(线程安全)。这里 instance 不会指向其他实例,用不上。当然,加上也没问题。

看到这里,单例模式的写法你已经学到了。后面的是加餐,可以选择不看了。

这个写法有一个不足之处,就是如果需要通过参数设置实例,则无法做到。举个栗子:

public class Singleton {
private static Singleton instance = new Singleton();

private Singleton() {
}

// 不能设置 name!
public static Singleton getInstance(String name) {
return instance;
}

public void show() {
System.out.println("Singleon using static initialization in Java");
}
}

// Here is how to access this Singleton class
Singleton.getInstance("test").show();

二、可通过参数设置实例的写法

考虑到这种情况,就在调用 getInstance() 方法时,再新建实例。

public class Singleton {
private static Singleton instance;

private String name;

private Singleton(String name) {
this.name = name;
}

public static synchronized Singleton getInstance(String name) {
if (instance == null) {
instance = new Singleton(name);
}
return instance;
}

public void show() {
System.out.println(name + ",hashcode: " + instance.hashCode());
}
}

Singleton.getInstance("test").show();

这里加了 synchronized 关键字,能保证线程安全(只会生成一个实例),但效率不高。因为实例创建成功后,再获取实例时就不用加锁了。

当不加 synchronized 时,会发生什么:

instance 是类的变量,类存放在方法区(元数据区),元数据区线程共享,所以类变量 instance 线程共享,类变量也是在主内存中。线程执行 getInstance() 时,在自己工作内存新建一个栈帧,将主内存的 instance 拷贝到工作内存。多个线程并发访问时,都认为 instance == null,就将新建多个实例,那单例模式就不是单例模式了。

测试:

public class Test {
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() -> {
Singleton.getInstance("test").show();
}).start();
}
}
}

三、改良版加锁的写法

实现只在创建的时候加锁,获取时不加锁。

public class Singleton {
private static volatile Singleton instance;

private Singleton() {
}

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

为什么要判断两次:

多个线程将 instance 拷贝进工作内存,即多个线程读取到 instance == null。虽然每次只有一个线程进入 synchronized 方法,当进入线程成功新建了实例,synchronized 保证了可见性(在 unlock 操作前将变量写回了主内存),此时 instance 不等于 null 了。但其他线程已经执行到 synchronized 这里了,某个线程就又会进入 synchronized 方法,如果不判断一次,就会再次新建一个实例。

为什么要用 volatile 修饰 instance:

synchronized 已经可以实现原子性、可见性、有序性,其中实现原子性:一次只有一个线程执行同步块的代码。但计算机为了提升运行效率,会指令重排序。

代码 instance = new Singleton(); 会被计算机拆为 3 步执行。

  • A:在堆中分配一块内存空间
  • B:在内存空间位置新建一个实例
  • C:将引用指向实例,即,引用存放实例的内存空间地址

线程可能按 ACB 执行,如果 instance 都在 synchronized 里面,怎么重排序都没啥问题。问题出现在还有 instance 在 synchronized 外边,因为此时外边一群饿狼(线程),就在等待一个 instance 这块肉不为 null。

模拟一下指令重排序的出错场景:多线程环境下,正好一个线程,在同步块中按 ACB 执行,执行到 AC 时(并将 instance 写回了主内存),另一个线程执行第一个判断时,从主内存拷贝了最新的 instance,认为 instance 不为空,返回 instance,但此时 instance 还没被正确初始化,所以出错。

volatile 修饰 instance 时,虚拟机在 ACB 后添加一个 lock 指令,lock 指令之前的操作执行完成后,后面的操作才能执行。只有当 ACB 都执行完了之后,其他线程才能读取 instance 的值,即:只有当写操作完成之后,读操作才能开始。这也是 Java 虚拟机规范的其中一条先行发生原则:对 volatile 修饰的变量,读操作,必须等写操作完成。

所以用 volatile 修饰 instance,是使用它的禁止指令重排序特性:禁止读指令重排序到写指令之前。(它禁止不了 lock 指令前的指令重排序。)

你可能认为上面的解释太复杂,不好理解。对,确实比较复杂,看不懂,下次问到再看吧。

四、其他非主流写法

枚举写法:

public enum Singleton{
INSTANCE;
}

当面试官让我写一个单例模式,我总是觉得写这个好像有点另类。

静态内部类写法:

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

这个写法还是比较有逼格的,但稍不注意就容易出错。

五、小结

单例模式主要为了节省内存开销,Spring 容器的 Bean 就是通过单例模式创建出来的。

单例模式没写出来,那也没啥事,因为那下一个问题你也不一定能答出来 :-)。

六、延伸阅读

DeppWang wechat
个人公众号