前言
Java 版的单例模式是以前写的了，最近又补充了 Kotlin 的写法，所以一起发出来。这里的 6+3 说的就是 Java 的 6 种 + Kotlin 的 3 种。更多设计模式可以看我之前写的 AndroidNotes。
一、介绍
定义
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
简单示例
public class Singleton {
private static Singleton instance = new Singleton;
private Singleton () {
}
public static Singleton getInstance() {
return instance;
}
}
上面就是一个单例模式的简单使用示例，可以看到确实是自行实例化的，并且使用的是私有构造函数，目的是为了其他地方不能通过构造函数来创建该类的实例，只能通过公共的 getInstance() 方法获取该类的实例。
二、Java 版
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;
}
}
小结：只有第一次用到的时候才初始化实例，解决了饿汉式造成内存浪费的问题，但是多线程的时候是不安全的。例如有线程 A 与线程 B 同时执行，这时候就有可能 2 个线程都同时执行到 if (instance == null)，这样就创建了 2 个实例了，所以这种方式只适用于单线程。
详细的多线程并发可以看我之前写的 带你通俗易懂的理解——线程、多线程与线程池 。
2.3 懒汉式（线程安全）
public class Singleton {
private static Singleton instance;
private Singleton() {
}
public static synchronized Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
小结：在 getInstance 方法上加了同步锁，这样有多个线程的时候会等前面的线程执行完了再执行当前线程，可以解决第二种懒汉式的线程安全问题。
2.4 双重校验锁（线程安全）
public class Singleton {
private volatile static Singleton instance;
private Singleton() {
}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
小结：可以看到加了双重 if (instance == null) 的判断，并且同步锁放到了方法内部，新增的第一个判空可以避免每个线程过来都去执行同步锁，可以解决同步锁造成的效率低的问题。
但是，instance = new Singleton(); 并不是一个原子操作，这一行代码可以分成 3 个步骤：
- 给 instance 分配内存
- 初始化 instance，即执行 new Singleton();
- 将 instance 对象指向分配的内存空间
而且由于 JVM 具有指令重排的特性，也就是说无法保证上面的 3 个步骤是按 1>2>3 执行的，有可能是 1>3>2。例如线程 A 执行完第 1 步与第 3 步，而没有执行第 2 步，显然 instance 是不为空的，这个时候线程 B 刚好执行到 if (instance == null) ，发现不为空就直接返回 instance，但是由于一直没有执行到第 2 步，所以 instance 虽然不为空，但是是没有初始化完成的，所以调用一个没有初始化完成的实例肯定是有问题的。
所以代码中使用了 volatile 关键字，因为它可以解决指令重排的问题，但是只能在 JDK 1.5 之后生效。而且使用 volatile 关键字也会影响一些性能问题。
2.5 静态内部类（线程安全）
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {
}
public static Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
小结：这种方式在 Singleton 类加载的时候并没有初始化实例，而是第一次调用 getInstance() 的时候才进行初始化，可以达到延迟加载对象的作用。并且 JVM 能确保 INSTANCE 只被实例化一次。也就是这种方式可以实现双重校验锁一样的效果，而且解决了使用 volatile 关键字只能在 JDK 1.5 之后生效和影响性能的问题。但是这种方式用的人还是比较少的。
2.6 枚举（线程安全）
public enum Singleton {
INSTANCE;
public void testMethod() {
}
}
小结：可以说使用枚举的方式实现单例是目前最完美的方式，这种方式可以防止序列化与反射造成的创建多个实例的问题，而前面的 5 种方式默认情况是无法解决这个问题的。可能使用枚举的唯一缺点是可读性不高。
关于序列化与反射造成的创建多个实例的问题可以看看这篇文章 为什么要用枚举实现单例模式（避免反射、序列化问题）。
三、Kotlin 版
3.1 懒汉式（线程安全）
看下 官方文档 的写法：
object Singleton
你没看错，一行代码就搞定！
那么他属于 Java 中的哪一种呢？
看下官方文档怎么说的：
Object declaration's initialization is thread-safe and done at first access.
即初始化是线程安全的，并且第一次用到的时候才初始化。也就是相当于 Java 版的第（3）、（4）、（5），不仅是懒汉式还是线程安全的。
那么内部原理是怎样的呢？
通过 Android Studio 转成 Java 代码看看：
public final class Singleton {
public static final Singleton INSTANCE;
private Singleton() {
}
static {
Singleton var0 = new Singleton();
INSTANCE = var0;
}
}
可以看到它确实是一个单例模式，这里是通过静态代码块来初始化实例的。
那么静态代码块是什么时候执行的呢？
我们知道类加载过程分为加载、验证、准备、解析、初始化 5 个阶段，而静态代码块就是在初始化这个阶段执行的，JVM 中规定了以下几种情况会触发类的初始化：
- 虚拟机启动时，会初始化包含 main 方法的主类。
- 通过 new 指令创建对象实例时。
- 访问类中的静态方法时。
- 访问类中的静态字段时。
- 对类进行反射调用时。
从上面转换的 Java 代码可知，当我们使用单例的时候，是通过 Singleton.INSTANCE 获取实例的，所以是通过访问类中的静态字段触发了类的初始化，也就是在这个时候执行了静态代码块。而且类的加载过程本身就是线程安全的，所以上面的单例不仅是懒汉式还是线程安全的。
3.2 枚举（线程安全）
enum class Singleton {
INSTANCE;
}
与 Java 版的第（6）种一样，可以防止序列化与反射造成的创建多个实例的问题。
3.3 带参数
可以看到，前面两种都无法像 Java 那样通过静态方法 getInstance() 传一个参数给单例：
public static Singleton getInstance(Context context) {}
那么我们可以模仿 官方的 demo 写一个：
class Singleton private constructor(context: Context) {
companion object {
@Volatile
private var instance: Singleton? = null
fun getInstance(context: Context) =
instance ?: synchronized(this) {
instance ?: Singleton(context).also { instance = it }
}
}
}
实际就是将 Java 版中的第（4）种 “双重校验锁” 转换成 Kotlin 的写法。
四、优缺点
优点
- 由于单例模式在内存中只有一个实例，对于需要频繁实例化然后销毁的对象可以减少内存开销。
- 由于单例只有一个实例，对于创建比较耗资源的对象可以减少系统的性能开销。
- 可以避免对资源的多重占用。
- 可以在系统设置全局的访问点，优化和共享资源访问。
缺点
- 单例模式一般没有接口，所以扩展困难，需要扩展只能修改原有的代码。
- 单例模式与单一职责原则有冲突。
五、使用场景
- 全局只需要一个实例的对象。
- 需要频繁实例化然后销毁的对象。
- 创建比较耗资源的对象，例如访问 IO 和数据库等资源。
六、如何选择？
- Java 版：以上 6 种方式各有利弊（线程安全问题、性能问题、代码复杂度与可读性问题），所以需要根据自己的项目选择合适的方式。一般建议使用第三种线程安全的懒汉式（例如 Android 系统源码中的 LocalBroadcastManager 就是使用该种方式），如果涉及到序列化与反射则可以使用第六种枚举的方式。
- Kotlin 版：一般情况下用第一种，如果涉及到序列化与反射则可以使用第二种枚举的方式，如果需要传参数则用第三种。
关于我
我是 wildma，CSDN 认证博客专家，简书程序员优秀作者，擅长屏幕适配。
如果文章对你有帮助，点个赞就是对我最大的认可！
