能说一说 Kotlin 中 lateinit 和 lazy 的区别吗？-阿里云开发者社区

能说一说 Kotlin 中 lateinit 和 lazy 的区别吗？

2022-12-28 166

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 能说一说 Kotlin 中 lateinit 和 lazy 的区别吗？

使用 Kotlin 进行开发，对于 latelinit 和 lazy 肯定不陌生。但其原理上的区别，可能鲜少了解过，借着本篇文章普及下这方面的知识。

lateinit

用法

非空类型可以使用 lateinit 关键字达到延迟初始化。

class InitTest() {
    lateinit var name: String
    public fun checkName(): Boolean = name.isNotEmpty()
}

如果在使用前没有初始化的话会发生如下 Exception。

AndroidRuntime: FATAL EXCEPTION: main
     Caused by: kotlin.UninitializedPropertyAccessException: lateinit property name has not been initialized
        at com.example.tiramisu_demo.kotlin.InitTest.getName(InitTest.kt:4)
        at com.example.tiramisu_demo.kotlin.InitTest.checkName(InitTest.kt:10)
        at com.example.tiramisu_demo.MainActivity.testInit(MainActivity.kt:365)
        at com.example.tiramisu_demo.MainActivity.onButtonClick(MainActivity.kt:371)
        ...

为防止上述的 Exception，可以在使用前通过 ::xxx.isInitialized 进行判断。

class InitTest() {
    lateinit var name: String
    fun checkName(): Boolean {
        return if (::name.isInitialized) {
            name.isNotEmpty()
        } else {
            false
        }
    }
}

Init: testInit():false

当 name 初始化过之后使用亦可正常。

class InitTest() {
    lateinit var name: String
    fun injectName(name: String) {
        this.name = name
    }
    fun checkName(): Boolean {
        return if (::name.isInitialized) {
            name.isNotEmpty()
        } else {
            false
        }
    }
}

Init: testInit():true

原理

反编译之后可以看到该变量没有 @NotNull 注解，使用的时候要 check 是否为 null。

public final class InitTest {
   public String name;
   @NotNull
   public final String getName() {
      String var10000 = this.name;
      if (var10000 == null) {
         Intrinsics.throwUninitializedPropertyAccessException("name");
      }
      return var10000;
   }
    public final boolean checkName() {
      String var10000 = this.name;
      if (var10000 == null) {
         Intrinsics.throwUninitializedPropertyAccessException("name");
      }
      CharSequence var1 = (CharSequence)var10000;
      return var1.length() > 0;
   }
}

null 则抛出对应的 UninitializedPropertyAccessException。

public class Intrinsics {
  public static void throwUninitializedPropertyAccessException(String propertyName) {
        throwUninitializedProperty("lateinit property " + propertyName + " has not been initialized");
    }
  public static void throwUninitializedProperty(String message) {
        throw sanitizeStackTrace(new UninitializedPropertyAccessException(message));
    }
  private static <T extends Throwable> T sanitizeStackTrace(T throwable) {
        return sanitizeStackTrace(throwable, Intrinsics.class.getName());
    }
    static <T extends Throwable> T sanitizeStackTrace(T throwable, String classNameToDrop) {
        StackTraceElement[] stackTrace = throwable.getStackTrace();
        int size = stackTrace.length;
        int lastIntrinsic = -1;
        for (int i = 0; i < size; i++) {
            if (classNameToDrop.equals(stackTrace[i].getClassName())) {
                lastIntrinsic = i;
            }
        }
        StackTraceElement[] newStackTrace = Arrays.copyOfRange(stackTrace, lastIntrinsic + 1, size);
        throwable.setStackTrace(newStackTrace);
        return throwable;
    }
}
public actual class UninitializedPropertyAccessException : RuntimeException {
    ...
}

如果是变量是不加 lateinit 的非空类型，定义的时候即需要初始化。

class InitTest() {
    val name: String = "test"
    public fun checkName(): Boolean = name.isNotEmpty()
}

在反编译之后发现变量多了 @NotNull 注解，可直接使用。

public final class InitTest {
   @NotNull
   private String name = "test";
   @NotNull
   public final String getName() {
      return this.name;
   }
   public final boolean checkName() {
      CharSequence var1 = (CharSequence)this.name;
      return var1.length() > 0;
   }
}

::xxx.isInitialized 的话进行反编译之后可以发现就是在使用前进行了 null 检查，为空直接执行预设逻辑，反之才进行变量的使用。

public final class InitTest {
   public String name;
   ...
   public final boolean checkName() {
      boolean var2;
      if (((InitTest)this).name != null) {
         String var10000 = this.name;
         if (var10000 == null) {
            Intrinsics.throwUninitializedPropertyAccessException("name");
         }
         CharSequence var1 = (CharSequence)var10000;
         var2 = var1.length() > 0;
      } else {
         var2 = false;
      }
      return var2;
   }
}

lazy

用法

lazy 的命名和 lateinit 类似，但使用场景不同。其是用于懒加载，即初始化方式已确定，只是在使用的时候执行。而且修饰的只是能是 val 常量。

class InitTest {
    val name by lazy {
        "test"
    }
    public fun checkName(): Boolean = name.isNotEmpty()
}

lazy 修饰的变量可以直接使用，不用担心 NPE。

Init: testInit():true

原理

上述是 lazy 最常见的用法，反编译之后的代码如下：

public final class InitTest {
   @NotNull
   private final Lazy name$delegate;
   @NotNull
   public final String getName() {
      Lazy var1 = this.name$delegate;
      return (String)var1.getValue();
   }
   public final boolean checkName() {
      CharSequence var1 = (CharSequence)this.getName();
      return var1.length() > 0;
   }
   public InitTest() {
      this.name$delegate = LazyKt.lazy((Function0)null.INSTANCE);
   }
}

所属 class 创建实例的时候，实际分配给 lazy 变量的是 Lazy 接口类型，并非 T 类型，变量会在 Lazy 中以 value 暂存，当使用该变量的时候会获取 Lazy 的 value 属性。

Lazy 接口的默认 mode 是 LazyThreadSafetyMode.SYNCHRONIZED，其默认实现是 SynchronizedLazyImpl，该实现中 _value 属性为实际的值，用 volatile 修饰。

value 则通过 get() 从 _value 中读写，get() 将先检查 _value 是否尚未初始化

已经初始化过的话，转换为 T 类型后返回

反之，执行同步方法（默认情况下 lock 对象为 impl 实例），并再次检查是否已经初始化：

已经初始化过的话，转换为 T 类型后返回

反之，执行用于初始化的函数 initializer，其返回值存放在 _value 中，并返回

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
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 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)
}

总之跟 Java 里双重检查懒汉模式获取单例的写法非常类似。

public class Singleton {
    private static volatile Singleton singleton;
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

lazy 在上述默认的 SYNCHRONIZED mode 下还可以指定内部同步的 lock 对象。

val name by lazy(lock) {
        "test"
    }

lazy 还可以指定其他 mode，比如 PUBLICATION，内部采用不同于 synchronized 的 CAS 机制。

    val name by lazy(LazyThreadSafetyMode.PUBLICATION) {
        "test"
    }

lazy 还可以指定 NONE mode，线程不安全。

    val name by lazy(LazyThreadSafetyMode.NONE) {
        "test"
    }

the end

lateinit 和 lazy 都是用于初始化场景，用法和原理有些区别，做个简单总结：

lateinit 用作非空类型的初始化：

在使用前需要初始化

如果使用时没有初始化内部会抛出 UninitializedPropertyAccess Exception

可配合 isInitialized 在使用前进行检查

lazy 用作变量的延迟初始化：

定义的时候已经明确了 initializer 函数体

使用的时候才进行初始化，内部默认通过同步锁和双重校验的方式返回持有的实例

还支持设置 lock 对象和其他实现 mode

能说一说 Kotlin 中 lateinit 和 lazy 的区别吗？

lateinit

用法

原理

lazy

用法

原理

the end

references

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

能说一说 Kotlin 中 lateinit 和 lazy 的区别吗？

lateinit

用法

原理

lazy

用法

原理

the end

references

热门文章

最新文章

相关课程

相关电子书