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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值