Kotlin lazy 实现原理

/**
 * Creates a new instance of the [Lazy] that uses the specified initialization function [initializer]
 * and the default thread-safety mode [LazyThreadSafetyMode.SYNCHRONIZED].
 *
 * If the initialization of a value throws an exception, it will attempt to reinitialize the value at next access.
 *
 * Note that the returned instance uses itself to synchronize on. Do not synchronize from external code on
 * the returned instance as it may cause accidental deadlock. Also this behavior can be changed in the future.
 */
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

上面的函数体为 lazy 的实现代码,该函数的参数为接收一个无参并返回值为 T 类型的函数,然后它的实现是 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
    // 重写 get 来保证懒加载,只在使用的时候才执行函数
    override val value: T
        get() {
            val _v1 = _value
            // 如果不为默认值则说明被其他线程或该线程已经初始化过,这也就是 lazy 只执行一次后续直接取值的原因
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                // 转为 T 类型返回
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    // lazy 返回值为该函数的执行结果
                    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)
}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Kotlin中的lazy是一种以惰性方式初始化属性的机制。它可以在属性第一次使用或调用时进行初始化,而不是在定义属性时立即初始化。这种机制能够提高代码的效率,并且特别适用于那些在定义时无法确定初始值的情况,比如在Android中的生命周期驱动属性。使用lazy机制可以延迟属性的初始化,直到它真正被需要。 在Kotlin中,可以通过将属性声明为lazy来使用这种机制。使用lazy函数,我们可以定义一个lambda表达式来初始化属性。该lambda表达式在属性第一次被使用或调用时被执行,并且结果被缓存起来,以便之后的使用。这种机制确保了属性的初始化只会在需要时进行,而不会浪费不必要的早期初始化。 下面是使用lazy的示例代码: ```kotlin val myLazyProperty: String by lazy { // 这里是属性的初始化代码 // 可以是任何复杂的逻辑 "Initializing my lazy property" } fun main() { // 第一次使用属性,进行初始化 println(myLazyProperty) // 输出:Initializing my lazy property // 再次使用属性,不进行初始化,直接使用缓存的结果 println(myLazyProperty) // 输出:Initializing my lazy property } ``` 在上述示例中,myLazyProperty是一个使用lazy机制的属性。当第一次访问该属性时,lambda表达式会被执行,属性会被初始化为"Initializing my lazy property"。之后再次访问该属性时,不会再执行lambda表达式,而是直接使用已经缓存的结果。 总结起来,Kotlin中的lazy机制允许我们以惰性方式初始化属性,只有在需要时才进行初始化。这种机制可以提高代码的效率,并且特别适用于那些无法在定义时确定初始值的情况[1]。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值