by lazy 的作用
延遲屬性(lazy properties) 是 Kotlin 標(biāo)準(zhǔn)庫中的標(biāo)準(zhǔn)委托之一，可以通過 by lazy 來實(shí)現(xiàn)。
其中，lazy() 是一個(gè)函數(shù)，可以接受一個(gè) Lambda 表達(dá)式作為參數(shù)，第一次調(diào)用時(shí)會執(zhí)行 Lambda 表達(dá)式，以后調(diào)用該屬性會返回之前的結(jié)果。
例如下面的代碼：
val str: String by lazy{
println(aaron)
println(cafei)
tony // 最后一行為返回值
}
fun main(args: Array) {
println(str)
println(-----------)
println(str)
}
執(zhí)行結(jié)果：
aaron
cafei
tony
-----------
tony
因?yàn)?lazy() 的最后一行，返回的值即為 str 的值，以后每次調(diào)用 str 都可以直接返回該值。
源碼分析
從 lazy() 開始分析源碼：
public actual funlazy(initializer: () - T): Lazy= SynchronizedLazyImpl(initializer)
actual 是 Kotlin 的關(guān)鍵字表示多平臺項(xiàng)目中的一個(gè)平臺相關(guān)實(shí)現(xiàn)。
lazy 函數(shù)的參數(shù)是 initializer，它是一個(gè)函數(shù)類型。lazy 函數(shù)會創(chuàng)建一個(gè) SynchronizedLazyImpl 類，并傳入 initializer 參數(shù)。
下面是 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 實(shí)現(xiàn)了 Lazy、Serializable 接口，它的 value 屬性重載了 Lazy 接口的 value。
Lazy 接口的 value 屬性用于獲取當(dāng)前 Lazy 實(shí)例的延遲初始化值。一旦初始化后，它不得在此 Lazy 實(shí)例的剩余生命周期內(nèi)更改。
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注解標(biāo)注，相當(dāng)于在 Java 中 使用 volatile 修飾 _value 屬性。volatile 具有可見性、有序性，因此一旦 _value 的值修改了，其他線程可以看到其最新的值。
SynchronizedLazyImpl 的 _value 屬性存儲了 initializer 的值。
如果 _value 的值等于 UNINITIALIZED_VALUE，則調(diào)用 initializer 來獲取值，通過synchronized來保證這個(gè)過程是線程安全的。
lazy() 方法還有一個(gè)實(shí)現(xiàn)，它比起上面的方法多一個(gè)參數(shù)類型 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 支持同時(shí)多個(gè)線程調(diào)用，并且可以在全部或部分線程上同時(shí)進(jìn)行初始化。但是，如果某個(gè)值已由另一個(gè)線程初始化，則將返回該值而不執(zhí)行初始化。
總結(jié)
lateinit 修飾的變量也可以延遲初始化，但并不是不用初始化，它需要在生命周期流程中進(jìn)行獲取或者初始化。
lateinit和by lazy的區(qū)別：
lateinit 只能用于修飾變量 var，不能用于可空的屬性和 Java 的基本類型。
lateinit 可以在任何位置初始化并且可以初始化多次。
lazy 只能用于修飾常量 val，并且 lazy 是線程安全的。
lazy 在第一次被調(diào)用時(shí)就被初始化，以后調(diào)用該屬性會返回之前的結(jié)果。
?