当前位置：首页 > article >正文

从源码角度分析 Kotlin by lazy 的实现

article 2024/11/11 5:02:36

by lazy 的作用

延迟属性(lazy properties) 是 Kotlin 标准库中的标准委托之一，可以通过 by lazy 来实现。

其中，lazy() 是一个函数，可以接受一个 Lambda 表达式作为参数，第一次调用时会执行 Lambda 表达式，以后调用该属性会返回之前的结果。

例如下面的代码：

val str: String by lazy{
    println("aaron")
    println("cafei")
    "tony"  // 最后一行为返回值
}

fun main(args: Array<String>) {
    println(str)
    println("-----------")
    println(str)
}

执行结果：

aaron
cafei
tony
-----------
tony

因为 lazy() 的最后一行，返回的值即为 str 的值，以后每次调用 str 都可以直接返回该值。

源码分析

从 lazy() 开始分析源码：

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

actual 是 Kotlin 的关键字表示多平台项目中的一个平台相关实现。

lazy 函数的参数是 initializer，它是一个函数类型。lazy 函数会创建一个 SynchronizedLazyImpl 类，并传入 initializer 参数。

下面是 SynchronizedLazyImpl 的源码：

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
    // 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
                }
            }
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)

 }

可以看到 SynchronizedLazyImpl 实现了 Lazy、Serializable 接口，它的 value 属性重载了 Lazy 接口的 value。

Lazy 接口的 value 属性用于获取当前 Lazy 实例的延迟初始化值。一旦初始化后，它不得在此 Lazy 实例的剩余生命周期内更改。

public interface Lazy<out T> {
    /**
     * Gets the lazily initialized value of the current Lazy instance.
     * Once the value was initialized it must not change during the rest of lifetime of this Lazy instance.
     */
    public val value: T

    /**
     * Returns `true` if a value for this Lazy instance has been already initialized, and `false` otherwise.
     * Once this function has returned `true` it stays `true` for the rest of lifetime of this Lazy instance.
     */
    public fun isInitialized(): Boolean
}

所以 SynchronizedLazyImpl 的 value 属性只有 get() 方法，没有 set() 方法。

value 的 get() 方法会先判断 _value 属性是否是 UNINITIALIZED_VALUE，不是的话会返回 _value 的值。

_value 使用@Volatile注解标注，相当于在 Java 中使用 volatile 修饰 _value 属性。volatile 具有可见性、有序性，因此一旦 _value 的值修改了，其他线程可以看到其最新的值。

SynchronizedLazyImpl 的 _value 属性存储了 initializer 的值。

如果 _value 的值等于 UNINITIALIZED_VALUE，则调用 initializer 来获取值，通过synchronized来保证这个过程是线程安全的。

lazy() 方法还有一个实现，它比起上面的方法多一个参数类型 LazyThreadSafetyMode。

public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
    when (mode) {
        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
    }

SYNCHRONIZED 使用的是 SynchronizedLazyImpl 跟之前分析的 lazy() 方法是一致的，PUBLICATION 使用的是 SafePublicationLazyImpl，而 NONE 使用的是 UnsafeLazyImpl。

其中，UnsafeLazyImpl 不是线程安全的，而其他都是线程安全的。

SafePublicationLazyImpl 使用AtomicReferenceFieldUpdater来保证 _value 属性的原子操作。毕竟，volatile 不具备原子性。

private class SafePublicationLazyImpl<out T>(initializer: () -> T) : Lazy<T>, Serializable {
    @Volatile private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    // this final field is required to enable safe publication of constructed instance
    private val final: Any = UNINITIALIZED_VALUE

    override val value: T
        get() {
            val value = _value
            if (value !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return value as T
            }

            val initializerValue = initializer
            // if we see null in initializer here, it means that the value is already set by another thread
            if (initializerValue != null) {
                val newValue = initializerValue()
                if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
                    initializer = null
                    return newValue
                }
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }

    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE

    override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."

    private fun writeReplace(): Any = InitializedLazyImpl(value)

    companion object {
        private val valueUpdater = java.util.concurrent.atomic.AtomicReferenceFieldUpdater.newUpdater(
            SafePublicationLazyImpl::class.java,
            Any::class.java,
            "_value"
        )
    }
}

因此 SafePublicationLazyImpl 支持同时多个线程调用，并且可以在全部或部分线程上同时进行初始化。但是，如果某个值已由另一个线程初始化，则将返回该值而不执行初始化。