Kotlin lazy 委托的底层实现原理

lazy 委托是 Kotlin 的一种属性委托，用于实现延迟初始化。所谓属性委托，就是将属性的 getter 和 setter 操作委托给其他对象来处理。lazy 委托允许我们在第一次访问属性时才进行初始化，后续访问直接返回已缓存的值。这种机制可以提高性能，避免不必要的开销，尤其是在处理开销较大的对象时。

使用

val lazyVal: String by lazy {
    println("Computed")
    "Lazy"
}
println(lazyVal)  // 输出: Computed, Lazy
println(lazyVal)  // 输出: Lazy（不再计算）

lazyVal 使用 lazy 委托延迟初始化，只有首次访问时执行初始化块 { println("Computed"); "Lazy" }，后续访问直接返回缓存值。

---

底层实现原理

Kotlin 的 lazy 委托是标准库中的一种属性委托，通过 by lazy { ... } 实现延迟初始化。其底层依赖于 Lazy<T> 接口和线程安全的实现类（默认使用 SynchronizedLazyImpl）。以下是实现细节：

1. lazy 委托的定义

• lazy 是一个高阶函数，定义在 Kotlin 标准库中：

  public fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

  • 参数 initializer: () -> T 是一个无参 Lambda，返回类型为 T（此处 T 是 String）。
  • 返回 Lazy<T> 接口实例，具体实现是 SynchronizedLazyImpl。
• Lazy<T> 接口：

  public interface Lazy<out T> {
      val value: T
      fun isInitialized(): Boolean
  }

  • value 属性获取委托值。
  • isInitialized() 检查是否已初始化。

这里把 lazyVal 的初始化逻辑封装在一个 Lazy 对象中，后续访问 lazyVal 时，实际上是访问这个 Lazy 对象的 value 属性。

2. SynchronizedLazyImpl 的实现

• lazy 默认使用 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 to ensure safe publication of 'SynchronizedLazyImpl' itself through
    // var lazy = lazy() {}
    private val lock = lock ?: this // 使用自身作为锁
  
    override val value: T
        get() {
            val _v1 = _value
  
            // 如果 _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!!() // 调用 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)
  }

• 关键点：

  • 延迟初始化：
    • _value 初始为 UNINITIALIZED_VALUE（哨兵对象）。
    • 首次访问 value 时，检查 _value 是否未初始化，若是则调用 initializer()（即 { println("Computed"); "Lazy" }）。
  • 线程安全：
    • 使用 @Volatile 确保 _value 的可见性。
    • synchronized(lock) 实现双重检查锁（Double-Checked Locking），保证多线程环境下初始化只执行一次。
  • 缓存结果：
    • 初始化后，_value 保存结果（"Lazy"），后续访问直接返回，无需再次调用 initializer。

3. 编译后的代码

• Kotlin 编译器将 lazyVal 的访问转换为对 Lazy 对象的调用。简化后的字节码（伪代码）：

  // 编译前
  val lazyVal: String by lazy { println("Computed"); "Lazy" }
  
  // 编译后（大致等效）
  private val lazyVal$delegate: Lazy<String> = lazy { println("Computed"); "Lazy" }
  val lazyVal: String
      get() = lazyVal$delegate.value

• 访问流程：

  • 第一次 lazyVal 访问：
    • 调用 lazyVal$delegate.value。
    • SynchronizedLazyImpl 执行 initializer，打印 Computed，返回 "Lazy"，并缓存。
  • 第二次访问：
    • 直接返回缓存的 _value（"Lazy"），无 initializer 调用。

---

其他懒加载模式

• lazy 支持不同线程安全模式，通过 LazyThreadSafetyMode 参数：

  val lazyVal: String by lazy(LazyThreadSafetyMode.NONE) { "Lazy" } // 无同步，单线程使用
  val lazyValPub: String by lazy(LazyThreadSafetyMode.PUBLICATION) { "Lazy" } // 允许多线程初始化，最终一致

• 默认 SYNCHRONIZED（如上述代码）适合多线程场景。

---

总结

• 底层实现：
  • lazy 委托通过 SynchronizedLazyImpl 实现延迟初始化。
  • 使用双重检查锁确保线程安全，首次访问执行 initializer，后续返回缓存值。
  • 编译器将 lazyVal 转换为 Lazy 对象的 value 访问。
• 关键机制：
  • 属性委托（by）将 get 操作转发给 Lazy。
  • @Volatile 和 synchronized 保证多线程安全。
  • _value 缓存初始化结果，优化性能。
• 实践：
  • lazy 适合昂贵初始化的场景（如数据库连接、配置加载）。
  • 注意线程安全模式的选择（默认 SYNCHRONIZED 适合多数场景）。

通过 lazy 委托，Kotlin 提供了一种高效、线程安全的延迟初始化机制。