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

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

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 支持同时多个线程调用,并且可以在全部或部分线程上同时进行初始化。但是,如果某个值已由另一个线程初始化,则将返回该值而不执行初始化。


总结



lateinit 修饰的变量也可以延迟初始化,但并不是不用初始化,它需要在生命周期流程中进行获取或者初始化。


lateinitby lazy的区别:


  1. lateinit 只能用于修饰变量 var,不能用于可空的属性和 Java 的基本类型。
  2. lateinit 可以在任何位置初始化并且可以初始化多次。
  3. lazy 只能用于修饰常量 val,并且 lazy 是线程安全的。
  4. lazy 在第一次被调用时就被初始化,以后调用该属性会返回之前的结果。
相关文章
|
Kotlin
Kotlin | 实现数据类(data)深拷贝
在Kotlin中,data数据类默认的copy方法实现的是浅拷贝,但我们有时候需要实现深拷贝。 在kotlin中,实现就比较容易了。
728 0
Kotlin | 实现数据类(data)深拷贝
|
4月前
|
安全 Android开发 Kotlin
Android经典面试题之Kotlin延迟初始化的by lazy和lateinit有什么区别?
**Kotlin中的`by lazy`和`lateinit`都是延迟初始化技术。`by lazy`用于只读属性,线程安全,首次访问时初始化;`lateinit`用于可变属性,需手动初始化,非线程安全。`by lazy`支持线程安全模式选择,而`lateinit`适用于构造函数后初始化。选择依赖于属性特性和使用场景。**
140 5
Android经典面试题之Kotlin延迟初始化的by lazy和lateinit有什么区别?
|
Java 开发者 Kotlin
Kotlin中的 lateinit 和 by lazy
Kotlin中的 lateinit 和 by lazy
186 0
|
设计模式 Kotlin
Kotlin设计模式实现之装饰者模式(Decorator)
装饰者模式(Decorator):在不改变对象自身的基础上,动态地给一个对象添加一些额外的职责。与继承相比,装饰者是一种更轻便灵活的做法。若要扩展功能,装饰者提供了比继承更有弹性的替代方法。
187 0
Kotlin设计模式实现之装饰者模式(Decorator)
|
设计模式 算法 Kotlin
Kotlin设计模式实现之策略模式
Kotlin设计模式实现之策略模式
185 0
Kotlin设计模式实现之策略模式
|
安全 Java 编译器
Kotlin | 关于 Lazy ,你应该了解的这些事
本文主要分享 Kotlin Lazy 相关,希望看完本篇,可以帮助到你更好的理解与使用。
404 0
Kotlin | 关于 Lazy ,你应该了解的这些事
|
存储 Kotlin
数据结构 | 二分搜索树及它的各种操作(kotlin实现)
在开始之前,应该先讲一下什么是二叉树。
117 0
数据结构 | 二分搜索树及它的各种操作(kotlin实现)
|
存储 C语言 Kotlin
重学数据结构-使用Kotlin实现链表及其他扩展
很简单,链表不像数组那样,不需要我们主动扩容,我们只需要类似递归一样,一层套一层即可,即node1持有node2的引用,node2持有node3…,相应的每次插入我们只需要更改头结点即可,当node-x持有的下一个node引用为null时,我们也可以判定,此时为链表尾节点。
264 0
|
算法 Kotlin
数据结构 | 使用Kotlin实现栈与队列
Last In First Out(LIFO) 后进先出 栈也是一种线性数据结构
668 0
|
Java Android开发 Kotlin
安卓一行代码实现避免按钮重复点击(AOP)java和kotlin都能使用
安卓一行代码实现避免按钮重复点击(AOP)java和kotlin都能使用
870 0