让业务需求决定资源生命周期:多消费者场景下的 callbackFlow 设计
在 Android 开发中,经常需要将回调式 API 包装成 callbackFlow:系统状态、SDK Listener、连接状态、定位、传感器、蓝牙、硬件数据等。
当多个模块都需要消费同一个信号时,常见问题是:
- 每个消费者是否都应独立注册回调?
- 是否需要将上游回调共享?
- 最后一个消费者离开后,谁负责释放资源?
- 后台任务仍需要资源,但 UI 已经消失时该怎么办?
这些问题背后真正的核心不是 callbackFlow,而是一个更通用的设计原则:
资源的生命周期应由使用者的业务需求决定,而不是由资源自身决定。
这里的“使用者”不等于 UI。它可以是:
- Activity、Fragment、Compose UI;
- ViewModel;
- Repository;
- 前台 Service;
- WorkManager 任务;
- 长连接管理器;
- 导航、录音、上传等领域任务;
- 应用级状态机。
只要仍有业务需要某项能力,资源就应持续可用;当所有使用者都不再需要它时,资源就应释放。
callbackFlow、shareIn、stateIn、Service、WorkManager 都只是这一原则在不同场景下的具体实现工具。
1. 不要让资源自己决定“该不该活着”
一个资源通常只应该负责两件事:
- 提供能力,例如注册回调、建立连接、读取状态;
- 在被要求停止时正确清理,例如反注册、断连、关闭句柄。
资源不应该自行猜测:
- 当前是否还有业务需要它;
- 应该在页面离开后继续运行还是立即停止;
- 应该被多个模块共享,还是让每个模块独立持有;
- 应该短暂保活,还是必须长期常驻。
这些是业务生命周期策略,应该由资源所有者决定。
可以将职责划分为:
底层资源
负责:注册、反注册、连接、断开、释放
资源所有者(Repository / Service / Manager)
负责:根据业务需求启动、共享、停止资源
使用者(UI / ViewModel / 后台任务)
负责:表达“我是否仍然需要这项能力”
例如,一个页面订阅某个状态,代表页面需要它;一个 Service 正在执行持续任务,也代表业务仍需要它。两者本质没有区别,只是需求来源不同。
2. callbackFlow 默认是冷流:每次收集都会注册一次回调
先看一个通用、脱敏的回调源:
data class Signal(
val value: Int,
)
fun interface SignalListener {
fun onChanged(signal: Signal)
}
interface SignalSource {
fun addListener(listener: SignalListener)
fun removeListener(listener: SignalListener)
}
将它包装为 callbackFlow:
fun SignalSource.observeSignals(): Flow<Signal> = callbackFlow {
val listener = SignalListener { signal ->
trySend(signal)
}
addListener(listener)
awaitClose {
removeListener(listener)
}
}
这段代码语义正确,但它是一个冷流。
每一次 collect 都会重新执行 callbackFlow 块:
val flow = source.observeSignals()
launch {
flow.collect { signal ->
println("Consumer A: $signal")
}
}
launch {
flow.collect { signal ->
println("Consumer B: $signal")
}
}
实际效果类似:
Consumer A 开始收集 -> addListener(listenerA)
Consumer B 开始收集 -> addListener(listenerB)
Consumer A 取消收集 -> removeListener(listenerA)
Consumer B 取消收集 -> removeListener(listenerB)
这不一定是问题。是否需要共享,取决于:
- 是否真的会同时存在多个消费者;
- 重复注册是否有成本;
- 信号是否表示一份共享领域状态;
- 是否希望新消费者立即拿到最近状态;
- 资源是否应随消费者数量自动启停。
3. 场景一:页面私有、单消费者、轻量回调
如果某个回调只属于当前页面,并且通常只有一个消费者,直接暴露冷 callbackFlow 通常是最简单、最合适的方案。
class DetailViewModel(
private val source: SignalSource,
) : ViewModel() {
val signals: Flow<Signal> = source.observeSignals()
}
页面通过生命周期感知方式收集:
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.signals.collect { signal ->
// Update UI
}
}
}
当页面停止时:
repeatOnLifecycle 取消 collect
↓
callbackFlow 被取消
↓
awaitClose 执行
↓
removeListener
这种场景下,不需要因为“未来可能有多个消费者”就提前引入共享逻辑。
轻量、局部、单消费者的资源,独立监听通常更清晰。
4. 场景二:多个消费者共享同一份领域状态
当一个信号代表共享的领域状态,并且可能被多个模块同时需要时,应该在统一的资源所有者中共享上游。
常见例子:
- 设备连接状态;
- 当前登录状态;
- 网络可用性;
- 高成本 SDK 状态;
- 系统服务状态;
- 高频硬件或传感器数据;
- 长连接状态;
- 多个页面都会展示的业务状态。
此时,Repository 通常是合理的共享边界:
底层回调源
↓
Repository:唯一的资源所有者
↓
共享 Flow
↓
多个 ViewModel / UI / UseCase
用 stateIn 共享状态
如果信号表达“当前状态”,例如连接状态、设备状态、开关状态,优先使用 stateIn:
class SignalRepository(
private val source: SignalSource,
private val applicationScope: CoroutineScope,
) {
private fun observeRawSignals(): Flow<Signal> = callbackFlow {
val listener = SignalListener { signal ->
trySend(signal)
}
source.addListener(listener)
awaitClose {
source.removeListener(listener)
}
}
.buffer(Channel.CONFLATED)
.distinctUntilChanged()
val signal: StateFlow<Signal?> = observeRawSignals()
.stateIn(
scope = applicationScope,
started = SharingStarted.WhileSubscribed(
stopTimeoutMillis = 5_000,
replayExpirationMillis = 0,
),
initialValue = null,
)
}
多个消费者可以收集同一个 StateFlow:
class FirstViewModel(
private val repository: SignalRepository,
) : ViewModel() {
val signal: StateFlow<Signal?> = repository.signal
}
class SecondViewModel(
private val repository: SignalRepository,
) : ViewModel() {
val signal: StateFlow<Signal?> = repository.signal
}
此时底层资源的生命周期由所有消费者的实际需求共同决定:
第一个消费者开始收集
↓
业务开始需要该信号
↓
stateIn 开始收集上游 callbackFlow
↓
注册一个底层 Listener
更多消费者开始收集
↓
共享同一个上游监听
↓
不会重复注册底层 Listener
最后一个消费者停止收集
↓
暂时不再有业务需要该信号
↓
等待 stopTimeoutMillis
仍无消费者
↓
取消上游 callbackFlow
↓
awaitClose 执行
↓
移除 Listener,释放资源
WhileSubscribed 的本质不是“自动管理 Flow”,而是:
将资源是否继续运行,绑定到是否仍有业务消费者需要它。
5. 用 shareIn 共享事件,而不是缓存状态
不是所有信号都是状态。
例如以下内容通常属于事件:
- 一次性通知;
- 消息到达;
- 操作结果;
- 临时错误提示;
- 页面跳转指令;
- 一次性的业务动作。
这类数据通常不应该在新消费者订阅后重放,因此使用 shareIn(replay = 0):
data class Notice(
val message: String,
)
class NoticeRepository(
private val source: NoticeSource,
private val applicationScope: CoroutineScope,
) {
val notices: SharedFlow<Notice> = source.observeNotices()
.shareIn(
scope = applicationScope,
started = SharingStarted.WhileSubscribed(
stopTimeoutMillis = 5_000,
),
replay = 0,
)
}
interface NoticeSource {
fun observeNotices(): Flow<Notice>
}
选择可以简单归纳为:
| 信号语义 | 推荐方案 |
|---|---|
| 页面私有、轻量、单消费者 | 冷 callbackFlow |
| 多消费者共享当前状态 | stateIn |
| 多消费者共享实时数据 | shareIn,按需设置 replay |
| 一次性事件 | shareIn(replay = 0) |
| 需要可靠保存和补偿的事件 | 数据库、任务队列或持久化状态 |
不要为了“避免丢事件”随意将 replay 调大。SharedFlow 的缓存不是可靠消息队列,也不能代替持久化。
6. WhileSubscribed 只是“消费者需求”驱动生命周期的一种实现
SharingStarted.WhileSubscribed 非常适合如下模型:
有活跃消费者时资源运行;没有活跃消费者时资源释放。
例如,页面显示设备状态:
UI 正在显示
↓
UI 需要设备状态
↓
保持底层监听
UI 不再显示,且无其他消费者
↓
业务不再需要设备状态
↓
停止底层监听
但同一个原则也适用于后台长期任务,只是“使用者”变成了 Service 或任务状态机,而不是 UI。
例如,一个前台 Service 执行持续业务:
Service 正在执行任务
↓
业务仍需要资源
↓
保持资源活跃
任务完成或 Service 停止
↓
业务不再需要资源
↓
释放资源
所以,长期运行的资源不是这个原则的例外。
它仍然是由使用者决定生命周期,只不过使用者是后台业务,而不是 Flow 订阅者。
7. 反例一:手工统计监听者数量
有时会尝试自行实现“引用计数”:
class IncorrectRepository(
private val source: SignalSource,
) {
private var consumerCount = 0
fun observe(): Flow<Signal> = callbackFlow {
consumerCount++
val listener = SignalListener { signal ->
trySend(signal)
}
source.addListener(listener)
awaitClose {
source.removeListener(listener)
consumerCount--
if (consumerCount == 0) {
releaseResource()
}
}
}
private fun releaseResource() {
// Release resource
}
}
这个方案的问题在于:
- 仍然重复注册了底层 Listener。
每个消费者都会执行一次addListener,计数并没有真正共享上游。 - 并发和取消顺序复杂。
多个协程可同时开始、取消、重建,普通计数很容易出现状态不一致。 - 页面快速切换会导致频繁启停。
一个消费者刚结束、另一个消费者马上开始时,资源可能被不必要地释放再重建。 - 业务代码在重复实现热流。
最终通常还会补上锁、延迟释放、缓存、广播、错误处理和状态机。
而 shareIn/stateIn + WhileSubscribed 已经提供了更可靠的消费者需求聚合机制。
因此,除非底层协议有非常特殊的生命周期要求,否则不建议手工维护监听者数量。
8. 反例二:从外部手动关闭 callbackFlow
另一个常见错误是保存 ProducerScope,然后由外部调用 close():
class IncorrectRepository(
private val source: SignalSource,
) {
private var activeScope: ProducerScope<Signal>? = null
fun observe(): Flow<Signal> = callbackFlow {
activeScope = this
val listener = SignalListener { signal ->
trySend(signal)
}
source.addListener(listener)
awaitClose {
source.removeListener(listener)
}
}
fun release() {
activeScope?.close()
}
}
这存在明显问题:
callbackFlow是流构建器,不是统一的资源句柄;- 多个消费者会对应多个 ProducerScope;
activeScope只能保存最后一次收集产生的 Scope;- 关闭一个 Scope 并不能正确代表其他消费者的状态;
- 外部强制关闭会让消费者收到意外的流结束信号;
- 生命周期规则被分散到外部调用点,难以验证所有路径都正确。
更合理的方式是让取消自然向上传递:
使用者不再需要信号
↓
停止 collect,或结束后台任务
↓
共享流失去订阅者 / 资源所有者收到停止指令
↓
取消上游 callbackFlow
↓
awaitClose 执行
↓
反注册并释放底层资源
9. 不要在每个 ViewModel 中各自共享同一资源
下面的写法看似使用了 stateIn,实际上仍可能重复注册底层回调:
class IncorrectViewModel(
source: SignalSource,
) : ViewModel() {
val signal = source.observeSignals()
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(),
initialValue = null,
)
}
如果存在多个 ViewModel,每个 ViewModel 都会创建自己的上游:
ViewModel A -> 独立 callbackFlow -> 独立 Listener
ViewModel B -> 独立 callbackFlow -> 独立 Listener
共享状态应放在共同的资源所有者中,例如 Repository:
一个 Repository
↓
一个共享上游
↓
多个 ViewModel 消费同一个 StateFlow / SharedFlow
viewModelScope 适合页面私有状态;跨页面、跨 ViewModel 或跨业务模块的共享资源,应使用有明确归属的应用级或业务级 Scope。
同时,不应使用 GlobalScope。资源生命周期应始终可追踪、可取消、有明确的业务所有者。
10. 最终决策:先找使用者,再决定资源生命周期
当需要封装一个回调资源时,可以按下面的顺序判断:
- 谁是资源的使用者?
当前页面、多个页面、Repository、后台 Service,还是一个长期任务? - 使用者何时不再需要它?
页面离开、任务完成、Service 停止、会话结束,还是应用退出? - 是否会同时存在多个使用者?
如果会,是否应共享同一个上游监听? - 重复注册的成本是什么?
只是内存 Listener,还是 Binder、网络、硬件、SDK、数据库或高频数据? - 信号是状态还是事件?
新订阅者是否应该得到最新值? - 资源是否必须脱离 UI 持续运行?
如果是,则由 Service、任务或领域状态机持有,而不是由 UI 订阅数量决定。
最终可以归纳为:
| 使用场景 | 资源所有者 | 生命周期触发方式 | 推荐方案 |
|---|---|---|---|
| 页面私有、轻量回调 | 页面或 ViewModel | UI 生命周期 | 冷 callbackFlow |
| 多消费者共享状态 | Repository | 活跃消费者集合 | stateIn(WhileSubscribed) |
| 多消费者共享事件 | Repository | 活跃消费者集合 | shareIn(WhileSubscribed) |
| 后台持续业务 | Service / 任务 / 状态机 | 任务生命周期 | 显式启动与停止 |
| 进程级基础能力 | Application 级所有者 | 应用或会话生命周期 | 明确的应用级管理 |
总结
多个消费者消费同一个信号时,重点不应是“是否总要使用 shareIn”,而应是:
当前哪些业务仍然需要这个资源?谁负责表达和聚合这些需求?
- 页面私有、轻量、单消费者:保持冷
callbackFlow,简单且正确。 - 多消费者共享同一领域状态:Repository 集中持有,使用
stateIn或shareIn。 - 最后一个消费者离开后释放资源:使用
WhileSubscribed。 - 后台任务仍需要资源:由 Service、任务或领域状态机继续持有。
awaitClose只负责正确释放底层回调;是否应释放,取决于业务需求。
资源不应该自己猜测何时该存活。业务需求才是资源生命周期的真正来源。