Repository 中的资源初始化:谁使用,谁触发

46 阅读6分钟

在 Android 开发中,我们经常会遇到这样的场景:

Repository 本身是一个 Singleton,但它依赖的某些资源并不适合在应用启动时就初始化。

比如访问网络需要 Retrofit,访问系统服务需要 getSystemService(),某些第三方 SDK 也可能需要执行一段初始化逻辑。

Repository 往往又提供多个业务接口:

class UserRepository {

    suspend fun getUser()
    suspend fun getProfile()
    suspend fun getOrders()
}

我们无法知道哪个接口会最先被调用。

如果在 Repository 创建时就把所有资源初始化:

class UserRepository {

    init {
        retrofit = createRetrofit()
        sdk = createSdk()
    }
}

那么即使这些资源最终根本没有被使用,也会承担初始化成本,还会让资源的生命周期过早开始。

因此,一个更自然的原则是:

谁真正需要这个资源,谁触发资源初始化。


不需要在应用启动时初始化资源

Repository 是 Singleton,并不意味着它里面所有资源都应该在 Repository 创建时初始化。

例如:

Application 启动
    ↓
创建 Repository
    ↓
资源暂时不创建

真正调用:

repository.getUser()

时:

getUser()
    ↓
发现需要 Retrofit
    ↓
初始化 Retrofit
    ↓
继续执行网络请求

这样资源的初始化时机由真实业务决定,而不是由应用启动决定。


suspend Repository 不应该依赖线程阻塞式初始化

Android 官方建议数据层的 suspend 函数应该是 main-safe,也就是说可以安全地从主线程调用;如果内部存在阻塞操作,应由执行工作的类通过 withContext 切换到合适的 Dispatcher。

因此,对于可能阻塞的资源,不能简单写成:

private val sdk by lazy {
    HeavySdk.initialize()
}

Kotlin 默认的 lazy 使用 SYNCHRONIZED 来保证只初始化一次,这意味着初始化过程使用线程级同步。

对于一个本身就是协程化的 Repository,我们更希望:

资源未初始化
    ↓
第一个协程触发初始化
    ↓
其他协程等待时挂起
    ↓
初始化完成
    ↓
所有协程继续执行

而不是让线程在锁上等待。


用 Mutex 实现可挂起的单次初始化

可以把资源初始化封装成一个 suspend 函数:

class UserRepository(
    private val ioDispatcher: CoroutineDispatcher
) {

    @Volatile
    private var sdk: HeavySdk? = null

    private val mutex = Mutex()

    private suspend fun getSdk(): HeavySdk {
        sdk?.let { return it }

        return mutex.withLock {
            sdk?.let { return@withLock it }

            val newSdk = withContext(ioDispatcher) {
                HeavySdk.initialize()
            }

            sdk = newSdk
            newSdk
        }
    }

    suspend fun getUser(): User {
        return getSdk().getUser()
    }

    suspend fun getProfile(): Profile {
        return getSdk().getProfile()
    }
}

这里有三个关键点。

第一次需要时才初始化

Repository 创建时:

Repository
    ↓
sdk == null

不会发生初始化。

真正第一次调用 getSdk() 时才开始。

并发调用只初始化一次

假设 A、B 两个协程同时第一次调用:

Coroutine A ──┐
              ├── getSdk()
Coroutine B ──┘

A 获得 Mutex 后开始初始化。

B 如果此时也需要资源,会在 Mutex 上挂起,而不是阻塞一个线程。初始化完成后,A 写入 sdk 并释放 Mutex,B 获得锁后再次检查:

sdk?.let { return@withLock it }

于是 B 直接复用 A 创建好的实例。

第二次检查不能省略,否则 B 获得锁以后仍然可能再次执行初始化。

为什么有 @Volatile

第一次检查发生在 Mutex 外:

sdk?.let { return it }

这是为了让已经初始化完成的资源走快速路径。

但既然这个读取没有经过 Mutex,就需要保证不同线程之间能够正确看到 sdk 的最新值,因此这里使用:

@Volatile
private var sdk: HeavySdk? = null

这样我们得到:

已经初始化
    ↓
直接读取 volatile
    ↓
返回资源

而只有第一次初始化时才需要竞争 Mutex。


初始化过程是否需要切 Dispatcher,要看资源本身

并不是所有资源初始化都需要:

withContext(ioDispatcher)

例如某个对象只是简单地创建几个 Kotlin 对象:

Retrofit.Builder()
    .baseUrl(...)
    .build()

这种初始化很轻量,就没有必要为了形式上的“协程安全”专门切线程。

真正需要关注的是:

初始化过程中有没有阻塞 I/O?
有没有大量 CPU 计算?
有没有其他明确的线程要求?

如果存在阻塞操作,就应该在资源持有者内部切换到合适的 Dispatcher。Android 官方也建议把 Dispatcher 注入,而不是让调用者决定 Repository 应该在哪个线程执行。

所以这里真正重要的不是“所有初始化都去 IO”,而是:

Repository 的 suspend 接口应该对调用者保持 main-safe。


初始化应该响应调用者的取消

假设:

Coroutine A
    ↓
开始初始化 SDK
    ↓
A 被取消

默认情况下,我们应该允许初始化一起取消。

因为这次初始化本来就是由 A 的业务需求触发的:

A 不需要了
    ↓
初始化也没有必要继续
    ↓
sdk 仍然为空

以后其他业务再次需要:

Coroutine B
    ↓
重新触发初始化

没有必要为了“将来可能有人使用”而让已经没有调用者的初始化继续运行。

因此通常也不需要:

withContext(NonCancellable) {
    ...
}

只有业务明确要求“初始化一旦开始就必须完成”时,才应该改变这种默认的取消语义。


DI 负责实例关系,Repository 负责初始化时机

使用 Hilt 或 Dagger 时,仍然可以让资源属于 Singleton scope:

@Provides
@Singleton
fun provideRetrofit(): Retrofit {
    ...
}

这里的 @Singleton 表达的是:

这个资源在对应的 DI Scope 内只有一个实例。

而不是:

这个资源必须在 App 启动时初始化。

资源是不是 Singleton,应该由资源本身的业务性质决定;初始化是否需要 suspend,是另外一个问题。

因此可以把两件事情分开:

资源的性质
    ↓
决定 Scope
    ↓
@Singleton


业务第一次需要
    ↓
触发初始化


初始化过程
    ↓
决定是否需要 withContext


多个协程同时第一次使用
    ↓
Mutex
    ↓
只初始化一次

资源的生命周期也要单独考虑

资源本身是否应该长期存在,并不是所有情况都一样。

例如 Retrofit:

创建一次
    ↓
长期复用

没有必要每次网络请求结束后销毁。

而定位则不同。

LocationClient 这样的客户端对象可以长期存在,但真正消耗系统资源的是:

requestLocationUpdates(...)

停止业务后应该:

removeLocationUpdates(...)

所以:

LocationClient
    ↓
可以长期复用


Location Updates
    ↓
有业务需要时启动
    ↓
没有业务需要时停止

因此不能把“资源初始化生命周期”和“资源执行工作的生命周期”混为一谈。


最后

Repository 中资源初始化真正需要解决的,并不是“应该什么时候把所有资源创建好”。

更自然的模型是:

Repository 是 Singleton
        ↓
资源按需初始化
        ↓
谁使用,谁触发
        ↓
suspend 初始化
        ↓
Mutex 保证并发只初始化一次
        ↓
竞争时协程挂起,而不是线程阻塞
        ↓
初始化成功后缓存并复用
        ↓
调用者取消,默认取消初始化

可以把它浓缩成一句话:

资源的 Scope 由资源本身的性质决定,而资源什么时候初始化,则由真正使用它的业务调用决定。

DI 负责管理“这个资源应该有几个实例、属于什么 Scope”,而 Repository 负责管理“什么时候真正需要它,以及初始化过程如何以协程友好的方式完成”。

这两个问题应该保持独立。