现在 Kotlin 的趋势日益高涨，Jake Wharton 大神近期从 Square 公司离职到 Google 负责 Kotlin 部分。我最近分析了 Kotlin 下的单例模式的实现方式，与 Java 下的实现有点区别，之前写过一篇 Java 设计模式之单例模式。下面主要从饿汉式和懒汉式两种方式来分享。
饿汉式
Kotlin 引入了 object 类型，可以很容易声明单例模式。
object Singleton {
...
}
// Kotlin 中调用
Singleton.xx()
// Java 中调用
Singleton.INSTANCE.xx()
这种方式和 Java 单例模式的饿汉式一样，不过比 Java 中的实现代码量少很多，其实是个语法糖。反编译生成的 class 文件后如下：
public final class Singleton {
public static final Singleton INSTANCE = null;
static {
Singleton singleton = new Singleton();
}
private Singleton() {
INSTANCE = this;
}
}
从反编译的代码可以看出 object 对象实际上还是利用了 INSTANCE 静态变量，所以在 Java 中调用时需要使用 Singleton.INSTANCE.xx()。
这种实现方式在类加载时就创建了单例对象，所以肯定是线程安全的，但是还是有饿汉式实现方式的问题：
如果构造方法中有耗时操作的话，会导致这个类的加载比较慢。
饿汉式一开始就创建实例，但是并没有调用，会造成资源浪费。
还有一个 Java 饿汉式单例模式没有的问题：无法自定义构造函数，object 中不允许 constructor 函数。
懒汉式
前面的 object 的实现方式是饿汉式的，开始使用前就实例化好了，如何在第一次调用时在初始化呢？Kotlin 中的延迟属性 Lazy 刚好适合这种场景。
class Singleton private constructor() {
companion object {
val instance: Singleton by lazy { Singleton() }
}
}
// Kotlin 中调用
Singleton.instance.xx()
// Java 中调用
Singleton.Companion.getInstance().xx()
Lazy 延迟属性默认是线程安全的，它具体是如何实现的呢？Java 中线程安全的懒汉式有 synchronized 修饰方法、双重检查锁定、静态内部类，更多内容请阅读 Java 设计模式之单例模式，下面看 Lazy 属性的源码：
public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
private var initializer: (() -> T)? = initializer
@Volatile private var _value: Any? = UNINITIALIZED_VALUE // 声明为 volatile 变量
// final field is required to enable safe publication of constructed instance
private val lock = lock ?: this
override val value: T
get() {
val _v1 = _value
if (_v1 !== UNINITIALIZED_VALUE) { // 第一次检查
@Suppress("UNCHECKED_CAST")
return _v1 as T
}
return synchronized(lock) { // 加锁锁定
val _v2 = _value
if (_v2 !== UNINITIALIZED_VALUE) { // 第二次检查
@Suppress("UNCHECKED_CAST") (_v2 as T)
}
else {
val typedValue = initializer!!()
_value = typedValue
initializer = null
typedValue
}
}
}
...
}
从上面代码中可以看出延迟属性 Lazy 内部也是使用双重检查锁定来实现线程安全的延迟初始化的。
LazyThreadSafetyMode
延迟属性 Lazy 默认线程安全模式是 LazyThreadSafetyMode.SYNCHRONIZED，使用同步锁的，LazyThreadSafetyMode 共有三种模式：
SYNCHRONIZED -- 使用同步锁保证只有一个线程可以初始化实例。
PUBLICATION -- 同一时期多个线程可以初始化实例，但是只有最先返回的值会作为延迟初始化的实例，使用 AtomicReferenceFieldUpdater.compareAndSet() 方法实现。
NONE -- 没有任何的线程安全的保证和开销。
例如，lazy (LazyThreadSafetyMode.PUBLICATION, { LazySingleton() })。
小结
内存占用低时，可以选择 object 声明的饿汉式单例模式，简单有效；
如果初始化时需要额外的操作或者实例资源消耗大时，推荐 Lazy 延迟属性的懒汉式单例模式。
