Kotlin 标准库为几种有用的委托提供了工厂方法。
- 延迟属性（lazy properties）: 其值只在首次访问时计算；
- 可观察属性（observable properties）: 监听器会收到有关此属性变更的通知；
- 把多个属性储存在一个映射（map）中，而不是每个存在单独的字段中。
延迟属性 Lazy
lazy() 是接受一个 lambda 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托.
val lazyValue: String by lazy {
println("set lazyValue")
"lazyInit"
}
fun main() {
println(lazyValue)
println(lazyValue)
}
// set lazyValue
// lazyInit
// lazyInit
从示例中可以看出,
当第一次使用到该值时,会调用
lambda函数,并且将函数返回值,赋给该变量. 后续则直接返回该值,而不再调用lambda函数.
修饰延迟属性只能使用val,说明延迟属性只能修饰不变的变量,它没有对应的set函数,只有get函数.
kotlin角度分析Lazy
点开lazy方法,跳转到LazyJVM.kt文件.
public actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer, lock)
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
_value = typedValue
// 置空函数,辅助GC
initializer = null
typedValue
}
}
}
...
}
lazy最后调用的是SynchronizedLazyImpl类中的相关方法.
当访问字段变量的时候,最终调用就是对应的get方法.
当_value有值时,则直接返回, 当_value没有值时,通过调用传入的lambda函数,得到lambda函数的返回值作为_value的值返回.
由此,实现懒加载的功能.
可以看出, 默认该方式是使用同步锁进行的,所以它是线程安全的.
即该值只在一个线程中计算，并且所有线程会看到相同的值。
lazy的三种模式
public enum class LazyThreadSafetyMode {
/**
* Locks are used to ensure that only a single thread can initialize the [Lazy] instance.
*/
SYNCHRONIZED,
/**
* Initializer function can be called several times on concurrent access to uninitialized [Lazy] instance value,
* but only the first returned value will be used as the value of [Lazy] instance.
*/
PUBLICATION,
/**
* No locks are used to synchronize an access to the [Lazy] instance value; if the instance is accessed from multiple threads, its behavior is undefined.
*
* This mode should not be used unless the [Lazy] instance is guaranteed never to be initialized from more than one thread.
*/
NONE,
}
lazy函数主要有3中模式
- SYNCHRONIZED 同步方式
延迟属性的值,只允许一个线程中修改,其他线程只能使用该线程修改的值.
- PUBLICATION 公共方式
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) {
// 初始化的lambda函数可被多个线程执行
val newValue = initializerValue()
// 通过CAS操作,只有一个线程,能够修改_value值
if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
initializer = null
return newValue
}
}
@Suppress("UNCHECKED_CAST")
return _value as T
}
允许多个线程在同一时刻进入初始化阶段,但是只有一个线程可以修改成功.
- NONE 模式
get() {
if (_value === UNINITIALIZED_VALUE) {
_value = initializer!!()
initializer = null
}
@Suppress("UNCHECKED_CAST")
return _value as T
}
线程不安全.
模式使用
val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
println("set lazyValue")
"lazyInit"
}
