Kotlin 委托函数之lazy

Kotlin 标准库为几种有用的委托提供了工厂方法。

• 延迟属性（lazy properties）: 其值只在首次访问时计算；
• 可观察属性（observable properties）: 监听器会收到有关此属性变更的通知；
• 把多个属性储存在一个映射（map）中，而不是每个存在单独的字段中。

延迟属性 Lazy

lazy() 是接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托.

val lazyValue: String by lazy {
    println("set lazyValue")
    "lazyInit"
}

fun main() {
    println(lazyValue)
    println(lazyValue)
}

// set lazyValue
// lazyInit
// lazyInit

从示例中可以看出,

当第一次使用到该值时,会调用lambda函数,并且将函数返回值,赋给该变量. 后续则直接返回该值,而不再调用lambda函数.

修饰延迟属性只能使用val,说明延迟属性只能修饰不变的变量,它没有对应的set函数,只有get函数.

kotlin角度分析Lazy

点开lazy方法,跳转到LazyJVM.kt文件.

public actual fun  lazy(lock: Any?, initializer: () -> T): Lazy = SynchronizedLazyImpl(initializer, lock)

private class SynchronizedLazyImpl(initializer: () -> T, lock: Any? = null) : Lazy, 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
                    _value = typedValue
                    // 置空函数,辅助GC
                    initializer = null
                    typedValue
                }
            }
        }
    ...
}

lazy最后调用的是SynchronizedLazyImpl类中的相关方法.

当访问字段变量的时候,最终调用就是对应的get方法.

当_value有值时,则直接返回, 当_value没有值时,通过调用传入的lambda函数,得到lambda函数的返回值作为_value的值返回.

由此,实现懒加载的功能.

可以看出, 默认该方式是使用同步锁进行的,所以它是线程安全的.

即该值只在一个线程中计算，并且所有线程会看到相同的值。

lazy的三种模式

public enum class LazyThreadSafetyMode {

    /**
     * Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
     */
    SYNCHRONIZED,

    /**
     * Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
     * but only the first returned value will be used as the value of [Lazy] instance.
     */
    PUBLICATION,

    /**
     * No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
     *
     * This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
     */
    NONE,
}

lazy函数主要有3中模式

• SYNCHRONIZED 同步方式

延迟属性的值,只允许一个线程中修改,其他线程只能使用该线程修改的值.

• PUBLICATION 公共方式

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) {
                // 初始化的lambda函数可被多个线程执行
                val newValue = initializerValue()
                // 通过CAS操作,只有一个线程,能够修改_value值
                if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
                    initializer = null
                    return newValue
                }
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }

允许多个线程在同一时刻进入初始化阶段,但是只有一个线程可以修改成功.

• NONE 模式

get() {
            if (_value === UNINITIALIZED_VALUE) {
                _value = initializer!!()
                initializer = null
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }

线程不安全.

模式使用

val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
    println("set lazyValue")
    "lazyInit"
}

引用

• 委托属性