从源码角度分析 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) {

　　println(str)

　　println(-----------)

　　println(str)

　　}

　　执行结果：

　　aaron

　　cafei

　　tony

　　-----------

　　tony

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

　　源码分析

　　从 lazy() 开始分析源码：

　　public actual funlazy(initializer: () - T): Lazy= SynchronizedLazyImpl(initializer)

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

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

　　下面是 SynchronizedLazyImpl 的源码：

　　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 = 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{

　　/**

　　* 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 funlazy(mode: LazyThreadSafetyMode, initializer: () - T): Lazy=

　　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(initializer: () - T) : Lazy, 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 修饰的变量也可以延迟初始化，但并不是不用初始化，它需要在生命周期流程中进行获取或者初始化。

　　lateinit和by lazy的区别：

　　lateinit 只能用于修饰变量 var，不能用于可空的属性和 Java 的基本类型。

　　lateinit 可以在任何位置初始化并且可以初始化多次。

　　lazy 只能用于修饰常量 val，并且 lazy 是线程安全的。

　　lazy 在第一次被调用时就被初始化，以后调用该属性会返回之前的结果。

​

转载于:https://juejin.im/post/5c7642cb6fb9a049be5e27cd