Kotlin 设计模式之单例模式

现在 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 延迟属性的懒汉式单例模式。