前言

由于源码分析的代码量比较大，大部分博客网站的内容显示页面都比较窄，显示出来的效果都异常丑陋，所以您也可以直接查看 《 Thinking in Android 》 来阅读这边文章，希望这篇文章能帮你梳理清楚 “ 单例模式 ”。

一、概述

1.1 什么是单例？

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

我们需要注意：

单例类：只能有一个实例(有且唯一)。

单例类：必须自己创建自己的唯一实例(自己创建自己)。

单例类：必须给所有其他对象提供这一实例(提供给别人调用自己的方法)。

1.2 举个例子

我们看个简单的 "单例设计" 的 Demo，先创建一个 Singleton(单例) 类：SingleObject.java

public class SingleObject {

//创建 SingleObject 的一个对象

private static SingleObject instance = new SingleObject(); --> 1、有且仅有一个实力；2、自己创建自己的实例

// 让构造函数为 private，这样该类就无法被实例化

private SingleObject(){}

// 获取唯一可用的对象

public static SingleObject getInstance(){ --> 3、为其他对象提供自己的实例

return instance;

}

public void showMessage(){

System.out.println("Hello World!");

}

}

然后我们再创建一个类 SingletonPatternDemo.java 去获取 SingleObject 的实例：

public class SingletonPatternDemo {

public static void main(String[] args) {

// 不合法的构造函数，编译时错误：构造函数 SingleObject() 是不可见的

//SingleObject object = new SingleObject();

// 获取唯一可用的对象

SingleObject object = SingleObject.getInstance();

// 显示消息

object.showMessage();

}

}

我们看下执行结果：

Hello World!

二、实现方式

2.1 基本版：饿汉式

代码范例

public class Singleton {

private static Singleton instance = new Singleton(); // 类加载时就初始化

private Singleton (){}

public static Singleton getInstance() {

return instance;

}

}

方法说明

这种方式比较常见，典型的 “饿汉式” 写法。

是否多线程安全

是

实现难度

易

优点

没有加锁，执行效率会提高

缺点

类加载时就初始化，浪费内存

2.2 改进版：懒汉式 - 线程不安全

代码范例

public class Singleton {

private static Singleton instance; // 类加载时不作初始化

private Singleton (){}

public static Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

方法说明

这种方式是大多数面试者的写法，也是教科书上的标配，但这段代码却存在一个致命的问题：当多个线程并行调用 getInstance() 的时候，就会创建多个实例。

是否多线程安全

否

实现难度

易

优点

第一次调用才初始化，避免内存浪费

缺点

当多个线程并行调用 getInstance() 的时候，就会创建多个实例。

2.3 改进版：懒汉式 - 线程安全

代码范例

public class Singleton {

private static Singleton instance;

private Singleton (){}

public static synchronized Singleton getInstance() { // 加锁

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

方法说明

既然要线程安全，那就如上所述进行 “加锁” 处理！

是否多线程安全

是

实现难度

易

优点

第一次调用才初始化，避免内存浪费

缺点

必须加锁 synchronized 才能保证单例，但加锁会影响效率(加锁操作也是耗时的)

2.4 改进版：双重校验锁

代码范例

public class Singleton {

private static Singleton instance;

private Singleton (){}

public static Singleton getSingleton() {

if (instance == null) {

synchronized (Singleton.class) {

if (instance == null) {

instance = new Singleton();

}

}

}

return instance;

}

}

方法说明

为什么需要进行 2 次判断是否为空呢？

第一次判断是为了避免不必要的同步，第二次判断是确保在此之前没有其他进程进入到 synchronized 块创建了新实例。

这段代码看起来很完美，很可惜，它还是有隐患！

主要在于 instance = new Singleton() 这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情：

✵ 1、给 instance 分配内存

✵ 2、调用 Singleton 的构造函数来初始化成员变量

✵ 3、将 instance 对象指向分配的内存空间(执行完这步 instance 就为非 null 了)

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

2.5 改进版：双检锁(volatile)

代码范例

public class Singleton {

private volatile static Singleton instance;

private Singleton (){}

public static Singleton getSingleton() {

if (instance == null) {

synchronized (Singleton.class) {

if (instance == null) {

instance = new Singleton();

}

}

}

return instance;

}

}

方法说明

有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。

使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。

也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上)，读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。

但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的，即使将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。

那么，有没有一种既有懒加载，又保证了线程安全，还简单的方法呢？

当然有，静态内部类就是这么一种我们想要的方法。我们完全可以把 Singleton 实例放在一个静态内部类中，这样就避免了静态实例在 Singleton 类加载的时候就创建对象，并且由于静态内部类只会被加载一次，所以这种写法也是线程安全的。

2.6 终极版：静态内部类

代码范例

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 本身的机制保证了线程安全的问题，同时读取实例的时候也不会进行同步，没什么性能缺陷，还不依赖 JDK 版本。

2.7 传说版：枚举

代码范例

public enum Singleton {

INSTANCE;

}

方法说明

这是从 Java 1.5 发行版本后就可以实用的单例方法，我们可以通过 Singleton.INSTANCE 来访问实例，这比调用 getInstance() 方法简单多了。

创建枚举默认就是线程安全的，所以不需要担心 double checked locking(双重校验锁)，而且还能防止反序列化导致重新创建新的对象。