让业务需求决定资源生命周期:多消费者场景下的 callbackFlow 设计

1 阅读11分钟

让业务需求决定资源生命周期:多消费者场景下的 callbackFlow 设计

在 Android 开发中,经常需要将回调式 API 包装成 callbackFlow:系统状态、SDK Listener、连接状态、定位、传感器、蓝牙、硬件数据等。

当多个模块都需要消费同一个信号时,常见问题是:

  • 每个消费者是否都应独立注册回调?
  • 是否需要将上游回调共享?
  • 最后一个消费者离开后,谁负责释放资源?
  • 后台任务仍需要资源,但 UI 已经消失时该怎么办?

这些问题背后真正的核心不是 callbackFlow,而是一个更通用的设计原则:

资源的生命周期应由使用者的业务需求决定,而不是由资源自身决定。

这里的“使用者”不等于 UI。它可以是:

  • Activity、Fragment、Compose UI;
  • ViewModel;
  • Repository;
  • 前台 Service;
  • WorkManager 任务;
  • 长连接管理器;
  • 导航、录音、上传等领域任务;
  • 应用级状态机。

只要仍有业务需要某项能力,资源就应持续可用;当所有使用者都不再需要它时,资源就应释放。

callbackFlow、shareIn、stateIn、Service、WorkManager 都只是这一原则在不同场景下的具体实现工具。


1. 不要让资源自己决定“该不该活着”

一个资源通常只应该负责两件事:

  1. 提供能力,例如注册回调、建立连接、读取状态;
  2. 在被要求停止时正确清理,例如反注册、断连、关闭句柄。

资源不应该自行猜测:

  • 当前是否还有业务需要它;
  • 应该在页面离开后继续运行还是立即停止;
  • 应该被多个模块共享,还是让每个模块独立持有;
  • 应该短暂保活,还是必须长期常驻。

这些是业务生命周期策略,应该由资源所有者决定。

可以将职责划分为:

底层资源
    负责:注册、反注册、连接、断开、释放

资源所有者(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
    }
}

这个方案的问题在于:

  1. 仍然重复注册了底层 Listener。
    每个消费者都会执行一次 addListener,计数并没有真正共享上游。
  2. 并发和取消顺序复杂。
    多个协程可同时开始、取消、重建,普通计数很容易出现状态不一致。
  3. 页面快速切换会导致频繁启停。
    一个消费者刚结束、另一个消费者马上开始时,资源可能被不必要地释放再重建。
  4. 业务代码在重复实现热流。
    最终通常还会补上锁、延迟释放、缓存、广播、错误处理和状态机。

而 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. 最终决策:先找使用者,再决定资源生命周期

当需要封装一个回调资源时,可以按下面的顺序判断:

  1. 谁是资源的使用者?
    当前页面、多个页面、Repository、后台 Service,还是一个长期任务?
  2. 使用者何时不再需要它?
    页面离开、任务完成、Service 停止、会话结束,还是应用退出?
  3. 是否会同时存在多个使用者?
    如果会,是否应共享同一个上游监听?
  4. 重复注册的成本是什么?
    只是内存 Listener,还是 Binder、网络、硬件、SDK、数据库或高频数据?
  5. 信号是状态还是事件?
    新订阅者是否应该得到最新值?
  6. 资源是否必须脱离 UI 持续运行?
    如果是,则由 Service、任务或领域状态机持有,而不是由 UI 订阅数量决定。

最终可以归纳为:

使用场景资源所有者生命周期触发方式推荐方案
页面私有、轻量回调页面或 ViewModelUI 生命周期冷 callbackFlow
多消费者共享状态Repository活跃消费者集合stateIn(WhileSubscribed)
多消费者共享事件Repository活跃消费者集合shareIn(WhileSubscribed)
后台持续业务Service / 任务 / 状态机任务生命周期显式启动与停止
进程级基础能力Application 级所有者应用或会话生命周期明确的应用级管理

总结

多个消费者消费同一个信号时,重点不应是“是否总要使用 shareIn”,而应是:

当前哪些业务仍然需要这个资源?谁负责表达和聚合这些需求?

  • 页面私有、轻量、单消费者:保持冷 callbackFlow,简单且正确。
  • 多消费者共享同一领域状态:Repository 集中持有,使用 stateIn 或 shareIn。
  • 最后一个消费者离开后释放资源:使用 WhileSubscribed。
  • 后台任务仍需要资源:由 Service、任务或领域状态机继续持有。
  • awaitClose 只负责正确释放底层回调;是否应释放,取决于业务需求。

资源不应该自己猜测何时该存活。业务需求才是资源生命周期的真正来源。