在 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 负责管理“什么时候真正需要它,以及初始化过程如何以协程友好的方式完成”。
这两个问题应该保持独立。