by lazy 的作用
延迟属性(lazy properties) 是 Kotlin 标准库中的标准委托之一,可以通过 by lazy 来实现。
其中,lazy() 是一个函数,可以接受一个 Lambda 表达式作为参数,第一次调用时会执行 Lambda 表达式,以后调用该属性会返回之前的结果。
例如下面的代码:
val str: String by lazy{
println("aaron")
println("cafei")
"tony" // 最后一行为返回值
}
fun main(args: Array<String>) {
println(str)
println("-----------")
println(str)
}
执行结果:
aaron
cafei
tony
-----------
tony
因为 lazy() 的最后一行,返回的值即为 str 的值,以后每次调用 str 都可以直接返回该值。
源码分析
从 lazy() 开始分析源码:
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
actual 是 Kotlin 的关键字表示多平台项目中的一个平台相关实现。
lazy 函数的参数是 initializer,它是一个函数类型。lazy 函数会创建一个 SynchronizedLazyImpl 类,并传入 initializer 参数。
下面是 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 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<out T> {
/**
* 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 属性是否是 UNINITIALIZEDVALUE,不是的话会返回 _value 的值。
_value 使用 @Volatile
注解标注,相当于在 Java 中 使用 volatile 修饰 _value 属性。volatile 具有可见性、有序性,因此一旦 _value 的值修改了,其他线程可以看到其最新的值。
SynchronizedLazyImpl 的 _value 属性存储了 initializer 的值。
如果 value 的值等于 UNINITIALIZEDVALUE,则调用 initializer 来获取值,通过 synchronized
来保证这个过程是线程安全的。
lazy() 方法还有一个实现,它比起上面的方法多一个参数类型 LazyThreadSafetyMode。
public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
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<out T>(initializer: () -> T) : Lazy<T>, 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
和 bylazy
的区别:
lateinit 只能用于修饰变量 var,不能用于可空的属性和 Java 的基本类型。
lateinit 可以在任何位置初始化并且可以初始化多次。
lazy 只能用于修饰常量 val,并且 lazy 是线程安全的。
lazy 在第一次被调用时就被初始化,以后调用该属性会返回之前的结果。
关注【Java与Android技术栈】
更多精彩内容请关注扫码: