Kotlin | 关于 Lazy ，你应该了解的这些事

    private val lock = "lock"
		
  	// 1. 基本写法(线程安全),内部使用Lazy自身实例作为锁对象
    val mutableAny by lazy() {
        mutableListOf<String>()
    }

  	// 2. (线程安全) 使用传入的lock作为锁对象
    val mutableAnyToLock by lazy(lock) {
        mutableListOf<String>()
    }

  	// 3. 原理与方式1相同
    val mutableToSyn by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
        mutableListOf<String>()
    }

  	// 4. (线程安全) 内部利用了CAS机制,不同于直接加同步锁
    val mutableToPub by lazy(LazyThreadSafetyMode.PUBLICATION) {
        mutableListOf<String>()
    }

  	// 5. (线程不安全) 多线程下可能会被初始化多次
    val mutableToNone by lazy(LazyThreadSafetyMode.NONE) {
        mutableListOf<String>()
    }

public interface Lazy<out T> {
		// 初始化的值
    public val value: T
		
		// 是否已初始化
    public fun isInitialized(): Boolean
}

internal object UNINITIALIZED_VALUE

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>，... {
    private var initializer: (() -> T)? = initializer
  	// 内部初始化的value,默认为一个静态类
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
  	// 默认使用Lazy自身实例作为锁对象,如果lock不为空
    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
          	// 如果不等于默认值,则证明已初始化过，直接强转返回
            if (_v1 !== UNINITIALIZED_VALUE) {
                return _v1 as T
            }
						
          	// 为初始化增加对象锁，锁对象为传递进来的lock,默认为当前自身对象
            return synchronized(lock) {
                val _v2 = _value
              	// 如果不等于默认值,则证明已初始化过，直接强转返回
                if (_v2 !== UNINITIALIZED_VALUE) {
                   _v2 as T
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }
			...
}

val mutableToSyn by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
    mutableListOf<String>()
}

internal object UNINITIALIZED_VALUE

private class SafePublicationLazyImpl<out T>(initializer: () -> T) : Lazy<T>, ... {
    @Volatile private var initializer: (() -> T)? = initializer
  	// 内部的value
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE

    override val value: T
        get() {
            val value = _value
            if (value !== UNINITIALIZED_VALUE) {
                return value as T
            }
          	// 先暂时存一下回调函数
            val initializerValue = initializer
          	// 如果回调函数为null,证明已经赋值完了
            if (initializerValue != null) {
              	// 去获取一下当前最新的值
                val newValue = initializerValue()
              	// 比较当前对象(this)中的_value,如果_value===UNINITIALIZED_VALUE,则赋值为newValue,比较内存地址
                if (valueUpdater.compareAndSet(this, UNINITIALIZED_VALUE, newValue)) {
                    initializer = null
                    return newValue
                }
            }
            return _value as T
        }

    ...

    companion object {
        private val valueUpdater = ...AtomicReferenceFieldUpdater.newUpdater(
            SafePublicationLazyImpl::class.java,
            Any::class.java,
            "_value"
        )
    }
}

val mutableToPub by lazy(LazyThreadSafetyMode.PUBLICATION) {
    mutableListOf<String>()
}

if (_valude == UNINITIALIZED_VALUE) {
       initializer = null
       _value=newVlude
       return newValue
}

internal class UnsafeLazyImpl<out T>(initializer: () -> T) : Lazy<T>... {
    private var initializer: (() -> T)? = initializer
    private var _value: Any? = UNINITIALIZED_VALUE

    override val value: T
        get() {
            if (_value === UNINITIALIZED_VALUE) {
                _value = initializer!!()
                initializer = null
            }
            @Suppress("UNCHECKED_CAST")
            return _value as T
        }
  	...
}

const val BUNDLE_KEY_TAG = "xxx_BUNDLE_KEY_TAG"

/** 为Fragment添加一个tag */
fun <T : Fragment> T.argument(key: String = BUNDLE_KEY_TAG, value: Parcelable): T {
    arguments = value.toFragmentBundle(key)
    return this
}

// Fragment related
inline fun <reified T : Any> Fragment.bundles(
    key: String = BUNDLE_KEY_TAG,
) = lazy(PUBLICATION) {
    val value = arguments?.get(key) ?: throw NullPointerException("Fragment.getBundle Null?")
    if (value is T) value else throw RuntimeException("Fragment.getBundle Type mismatch")
}

private val searchKey by bundles<SearchUserKey>()

@MainThread
fun <T> createAdapter(
    @LayoutRes layout: Int,
    obj: QuickAdapterBuilder<T>.() -> Unit
): Lazy<BaseQuickAdapter<T, BaseViewHolder>> = lazy(NONE) {
    QuickAdapterBuilder<T>().apply {
        setLayout(layout)
        obj()
    }.adapter
}

class QuickAdapterBuilder<T> {

  	@LayoutRes
    private var layout: Int = 0

    private var convert: ((holder: BaseViewHolder, data: T) -> Unit)? = null

    private var init: (BaseQuickAdapter<T, BaseViewHolder>.() -> Unit)? = null

    fun setLayout(@LayoutRes layout: Int) {
        this.layout = layout
    }

    fun onBind(convert: (holder: BaseViewHolder, data: T) -> Unit) {
        this.convert = convert
    }

    fun init(init: BaseQuickAdapter<T, BaseViewHolder>.() -> Unit) {
        this.init = init
    }

   	internal val adapter: BaseQuickAdapter<T, BaseViewHolder> =
        object : BaseQuickAdapter<T, BaseViewHolder>(layout), LoadMoreModule {
            init {
                init?.invoke(this)
            }

            override fun convert(holder: BaseViewHolder, item: T) {
                convert?.invoke(holder, item)
            }
        }
}