一. 序
单例模式是我们在日常编程中，比较常用的设计模式。一个好的单例，必然需要满足唯一性和线程安全性。而 Java 中，关于单例的文章讲解已经很完善了，单例模式已经成为一种编程范式。
在谷歌强推 Kotlin 的今天，不少人使用 Kotlin 时，还带着 Java 的编程思维，并没有有效的利用 Kotlin 的一些特性。如果还用 Java 的编程思想来写 Kotlin 的单例，会有种四不像的感觉。
在 Kotlin 里，想要实现单例模式，只需要将类增加 object 关键字即可，这就是一个线程安全的单例模式，很方便。
但是这存在一个问题，object class 无法实现构造方法，也就是我们无法在初始化的时候，从外部传递一些参数来让这个单例类初始化。
本文就来聊聊 Kotlin 下的单例模式的实现，以及如何优雅的构造一个带参数的单例模式。
二. Kotlin 的单例
2.1 object class 的单例
虽然无法在构造的时候，从外部传递参数，但是 object 关键字依然是 Kotlin 下，最常用的构造单例方法，我们先来了解它的特性。
object 关键字使用起来非常简单，只需要直接作用在 class 上就好。
object SomeSingleton{
fun sayHi(){}
}
这就是在 Kotlin 下，最简单的单例模式，如果想要有一些初始化的动作，可以放在 init 块中。
object SomeSingleton{
init{
// init
}
fun sayHi(){}
}
使用方法也非常简单，需要注意的是，在 Kotlin 中调用和 Java 调用存在一些差异。
// Kotlin Language
SomeSingleton.sayHi()
// Java Language
SomeSingleton.INSTANCE.sayHi()
我们知道，Kotlin 和 Java 是可以无缝互通的，而 Kotlin 最终编译的字节码，其实也是可以转成类 Java 的代码。
那我们继续看看 Kotlin 的 object 关键字后，在 Java 中的表现到底如何。通过这种转码的分析，可以便于我们理解 Kotlin 的特性。
借助 AS 的 Tools → Kotlin → Show Kotlin Bytecode，就可以查看 Kotlin 文件的字节码，再点击 Decompile 按钮，就可以将字节码转成 Java 代码。
有对比就清晰了，Kotlin 的 object 关键字，在 Java 表现的特点如下：
-
类用 final 标记，标识不可变性。
-
内部声明一个 static final 的当前类的对象 INSATNCE。
-
在静态代码块中，进行 INSTANCE 对象的初始化。
可以看到，在 Kotlin 的 object 中，是使用类的初始化锁来保证线程安全的。
那什么是类的初始化锁？
简单来说， JVM 在类的初始化阶段（即在 Class 被加载后，且被线程使用之前），会执行类的初始化，在初始化期间，JVM 会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化，避免多线程调用时，引发线程安全的问题。
上图很清晰的表明了类的初始化锁的工作流程。
而 Kotlin 中的 object 关键字，就是利用类的初始化锁来保证线程安全的，在我们不需要为单例的初始化传递外部参数的场景下，可以放心使用。
那可能有人担心另一个问题，类加载的时候就初始化构造单例对象，是不是对资源的利用不友好？
这一点问题不大，虚拟机在运行程序的时候，并不是在启动时就将所有的类，都加载进来并初始化完成，而是一种按需加载的策略，在真正使用它的时候，才会初始化。
例如：new Class、调用静态方法、反射、调用 Class.forName() 方法等。这一点可以通过本文介绍的单例实现，在 init 块中输出 Log，看看 Log 何时输出来验证，相关资料很多，就不多说了。
也就是说，通常只有在你真实使用这个类时，它才会真的被虚拟机初始化。当然，不同虚拟机的实现方式不同，这并不是强制的，但是大多数为了性能都会准守此规则。
2.2 传参数的单例
无参单例可以用 object 关键字，但如果想通过一些外部参数初始化单例呢？Kotlin 的 object 是不能有任何构造函数的，所以也无法传递任何参数。
带参单例在 Android 中也是有一些使用场景的，例如 Android 中的 LocalBroadcastManager，就是一个带参的单例模式。
LocalBroadcastManager.getInstance（context）.sendBroadcast（intent）
那换个思路想想，在 Java 中，带参数的单例如何实现？通常都会用双重检查锁（Double Checked Locking） + volatile 关键字来解决。
public class DoubleCheckSingleton {
private volatile static DoubleCheckSingleton sInstance;
private DoubleCheckSingleton(Context ctx) {
// init
}
public static DoubleCheckSingleton getInstance(Context ctx) {
if (sInstance == null) {
synchronized (DoubleCheckSingleton.class) {
if (sInstance == null) {
sInstance = new DoubleCheckSingleton(ctx);
}
}
}
return sInstance;
}
}
加上 volatile 是为了可见性和禁止重排序，这样就可以保证把参数传递进去的同时，确保线程安全。
不过在 Kotlin 中是没有 volatile 关键字的，取而代之的是 @Volatile 注解，同时需要配合 Kotlin 的伴生对象进行单例模式的构建。
伴生对象可以简单的使用类名作为限定符来调用其方法，类似 Java 中的静态方法。
final class SomeSingleton(context: Context) {
private val mContext: Context = context
companion object {
@Volatile
private var instance: SomeSingleton? = null
fun getInstance(context: Context): SomeSingleton {
val i = instance
if (i != null) {
return i
}
return synchronized(this) {
val i2 = instance
if (i2 != null) {
i2
} else {
val created = SomeSingleton(context)
instance = created
created
}
}
}
}
}
这段代码是直接借鉴的 Kotlin 的 lazy()，lazy 在默认情况下的实现是 SynchronizedLazyImpl，从类名上就能看出来，它使用 synchroinzed 来保证线程安全。
用这样的方式，就可以实现一个可以传参数去构造的单例模式。
2.3 封装一个带参单例
支持传参的单例，我们实现了。但为了实现这个单例，写了 20+ 行代码。每次写单例都要把这一堆代码复制一遍，还挺麻烦，为了使用方便，还可以将其再封装一下。
open class SingletonHolder<out T, in A>(creator: (A) -> T) {
private var creator: ((A) -> T)? = creator
@Volatile
private var instance: T? = null
fun getInstance(arg: A): T {
val i = instance
if (i != null) {
return i
}
return synchronized(this) {
val i2 = instance
if (i2 != null) {
i2
} else {
val created = creator!!(arg)
instance = created
creator = null
created
}
}
}
}
用一个支持继承的 open class 加上泛型就可以简单的将其进行封装，此封装方式支持一个参数的构造方法，有需要可以继续扩展或者封装。
class SomeSingleton private constructor(context: Context) {
init {
// Init using context argument
context.getString(R.string.app_name)
}
companion object : SingletonHolder<SomeSingleton, Context>(::SomeSingleton)
}
封装成 SingletonHolder 类之后，再想使用单例，关键代码一行就搞定了。
2.4 使用 lazy
前面在介绍带参单例的时候，也提到了lazy()，它是 Kotlin 的一种标准委托，可以接受一个 lambda 并返回一个实例的函数。
如果我们想要延迟初始化，可以使用 lazy() 这个代理来实现，它会在第一次调用get() 方法时，执行 lazy() 的 lambda 表达式并记录结果，之后再调用 get()就只会返回之前记录的结果，非常适合延迟初始化的场景。
class SomeSingleton{
companion object {
val instance: SomeSingleton by lazy { SomeSingleton() }
}
}
lazy() 默认情况下，内部就是依赖同步锁（synchronized）来实现的，所以它也是线程安全的。
但是正如我前面提到的，类本身也是按需加载的，调用它的下一步肯定是也需要使用它，所以只要我们正确的使用单例模式，其实没必要使用 lazy()，这里仅做一个介绍，大家知道一下就好了。
三. 小结时刻
本文介绍了在 Kotlin 下，实现单例模式的一些代码技巧，希望对大家有所帮助。最后再简单总结一下。
-
无参单例模式，直接使用 Kotlin 的
object即可，它是依赖类的初始化锁来保证线程安全。 -
带参单例模式，可以使用双重检查锁 +
@Volatile来实现，如果嫌麻烦还可以封装成 SingletonHolder。 -
lazy()委托确实可以实现延迟加载，但是在单例模式的场景下，不如直接用object方便。
网友评论