Kotlin lateinit 和 by lazy实现原理

lateinit

lateinit：用来修饰var类型成员变量，用来表示该变量可以在晚些时候初始化，用来避免不必要的空检查。自Kotlin1.2版本开始，lateinit也可以用来修饰顶层变量和局部变量。

//顶层变量
lateinit var topVariable: String

class MyTest {
    //成员变量
    lateinit var name: String

    fun myfun() {
        //局部变量
        lateinit var address: String

    }
}

注意：

lateinit不能修饰原始数据类型，原始类型的数据应该使用默认的数据来进行初始化，比如Int类型的变量可以使用0进行初始化。
lateinit修饰的var类型变量不能有自定义的getter和setter。

如果我们访问一个 lateinit修饰的var类型变量，但是该变量没有被初始化，那么就会抛出异常。

kotlin.UninitializedPropertyAccessException: lateinit property name has not been initialized

自Kotlin1.2版本开始，我们可以检查一个lateinit var类型变量的变量是否被初始化了。

lateinit var topVariable: String

fun main() {

    val myTest = MyTest()
    myTest.check()
    //为什么不能在这里检车MyTest的name属性是否被初始化了呢？还不清楚
    //println(myTest::name.isInitialized)
    println(::topVariable.isInitialized)
}

class MyTest {

    lateinit var name: String

    fun check() {
        if (this::name.isInitialized) {
            println(name)
        } else {
            println("name 还没有初始化")
        }
    }
}

lateinit的实现原理：我感觉没什么原理吧，应该就是告诉编译器不要去检查变量是否为空。然后我们在引用变量的时候就判断一下，如果变量为空，也就是没有初始化，那么就抛出异常，否者就正常返回。

查看反编译的Kotlin字节码，只看生成的getName方法

//注释1处
@NotNull
public final String getName() {
      String var10000 = this.name;
      //注释2处，检查
      if (var10000 == null) {
         Intrinsics.throwUninitializedPropertyAccessException("name");
      }

      return var10000;
}

注释1处，标记这个方法返回不为空。
注释2处，检查，如果变量为空了，抛出异常。

总结：lateinit可以用来修饰var类型变量来避免不必要的检查，自Kotlin1.2版本开始，我们可以检查一个lateinit var类型变量的变量是否被初始化了。

lazy

lazy可以用来实现val类型变量的延迟初始化。可以修饰成员变量，修饰顶层变量和局部变量。

//修饰顶层变量
val topInt: Int by lazy {
    1
}

fun main() {
    val byLazyTest = ByLazyTest()
    byLazyTest.printName()
}

class ByLazyTest {
    //修饰成员变量
    private val name: String by lazy {
        "dmw"
    }

    fun printName() {
        //修饰局部变量
        val address: String by lazy {
            "dmw"
        }

        print(this.name)
    }
}

我们以一个最简单的例子来分析，如下所示：

class LazyInitDemo {

     val myName: String by lazy(getNameFromPreference())

    private fun getNameFromPreference(): () -> String = { "John" }

}

其实我们也可以简单的写成下面这样。

class LazyInitDemo {
    val myName: String by lazy{"John"}
}

我们先来看看 lazy 这个方法的签名

方法定义在LazyJVM.kt文件中

/**
 * 使用指定的初始化函数[initializer]来创建一个[Lazy] 类型的对象。
 * 默认的线程模型是[LazyThreadSafetyMode.SYNCHRONIZED].
 */
public actual fun  lazy(initializer: () -> T): Lazy = 
            SynchronizedLazyImpl(initializer)

注释中已经很清晰了：使用指定的初始化函数[initializer]来创建一个[Lazy] 类型的对象。默认的线程模型是[LazyThreadSafetyMode.SYNCHRONIZED]。返回的是一个SynchronizedLazyImpl类型的对象。线程模型是什么东西？就是为了处理传入的初始化函数[initializer]的调用，在单线程或者多线程下的调用。lazy方法还有一个重载函数，我们可以显式的传入线程模型。

public actual fun  lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy =
    when (mode) {
        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
}

这里我们就不讨论线程模型的问题了，大家可以看一看，很简单。

通过上面的叙述我们可以知道，by lazy指定的函数就是一个lambda表达式{ "John" }，是一个() -> T类型的初始化函数。

查看反编译的Kotlin字节码

public final class LazyInitDemo {

   //注释1处
   @NotNull
   private final Lazy myName$delegate = LazyKt.lazy(this.getNameFromPreference());
   
   @NotNull
   public final String getMyName() {
      Lazy var1 = this.myName$delegate;
      //注释2处
      return (String)var1.getValue();
   }

   private final Function0 getNameFromPreference() {
      return (Function0)null.INSTANCE;
   }
}

注释1处，生成了一个Lazy类型的变量myName$delegate，就是我们的属性名加上后缀$delegate。我们知道默认情况下返回的是一个SynchronizedLazyImpl对象。

注释2处，调用SynchronizedLazyImpl的getValue方法。我们来看一看：

SynchronizedLazyImpl类在LazyJVM.kt文件中

//LazyJVM.kt
internal object UNINITIALIZED_VALUE

UNINITIALIZED_VALUE用来表示value是否初始化了

//LazyJVM.kt
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
    //重写了value属性
    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                //注释1处，已经初始化了，直接返回
                return _v1 as T
            }
            //使用同步方法，避免多次初始化
            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNINITIALIZED_VALUE) {
                    //注释2处，别的线程已经初始化了，直接返回
                    (_v2 as T)
                } else {
                    //注释3处，调用传入的lambda进行初始化并返回
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }
    //是否已经初始化了
    override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE
    //...
}

注释1处，如果 _value!= UNINITIALIZED_VALUE，说明已经调用传入的initializer初始化过了，直接返回_value。
注释2处，如果别的线程已经初始化了，直接返回_value。
注释3处，当前还没有初始化就调用initializer进行初始化，并将初始化值赋值给_value，然后返回。

以后每次调用getValue方法都是直接将_value的值返回，从而实现属性值的唯一一次初始化。

其实到这里lazy的实现原理已经很清楚了，我们再结合图片总结一下：