×

Kotlin 设计模式之单例模式

96
JohnnyShieh
2017.08.24 11:59 字数 743

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

Kotlin
Web note ad 1