能否用Kotlin Flow实现等效LiveEvent？支持新订阅者收新值且可访问最后值

完全可以实现你想要的效果：既保留LiveEvent“新订阅者仅接收订阅后新值”的特性，又支持主动访问最后一次发射的值，同时兼容你指定的背压配置。

核心实现思路 #

你给出的MutableSharedFlow配置（replay=0、extraBufferCapacity=1、DROP_LATEST）已经能保证新订阅者不会收到历史值，但无法直接读取缓存的最后值。我们可以通过封装MutableSharedFlow+线程安全的变量保存最后值的方式来实现需求。

完整代码实现 #

import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

class LiveEventFlow<T>(
    extraBufferCapacity: Int = 1,
    onBufferOverflow: MutableSharedFlow.BufferOverflow = MutableSharedFlow.BufferOverflow.DROP_LATEST
) {
    // 内部使用replay=0的SharedFlow，保证新订阅者只收新值
    private val _internalFlow = MutableSharedFlow<T>(
        replay = 0,
        extraBufferCapacity = extraBufferCapacity,
        onBufferOverflow = onBufferOverflow
    )
    // 对外暴露只读的SharedFlow
    val flow: SharedFlow<T> = _internalFlow.asSharedFlow()

    // 线程安全的最后值存储，用Mutex保证多线程环境下的一致性
    private val lastValueMutex = Mutex()
    private var lastValue: T? = null

    /**
     * 发射新值，同时更新最后值缓存
     */
    suspend fun emit(value: T) {
        lastValueMutex.withLock {
            lastValue = value
        }
        _internalFlow.emit(value)
    }

    /**
     * 非协程环境下同步获取最后值（如果锁竞争失败则返回null）
     */
    fun getLastValue(): T? {
        val locked = lastValueMutex.tryLock()
        return try {
            if (locked) lastValue else null
        } finally {
            if (locked) lastValueMutex.unlock()
        }
    }

    /**
     * 协程环境下安全获取最后值（会等待锁释放）
     */
    suspend fun getLastValueSuspend(): T? {
        return lastValueMutex.withLock { lastValue }
    }
}

关键特性说明 #

• LiveEvent核心特性：内部MutableSharedFlow的replay=0确保新订阅者只会收到订阅之后发射的新值，不会触发历史值的回调。
• 可访问最后值：通过线程安全的变量保存每次发射的值，提供同步/协程两种获取方式，满足不同场景的需求。
• 兼容指定背压配置：保留了你设置的extraBufferCapacity和onBufferOverflow，背压处理逻辑与原配置完全一致。

使用示例 #

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

fun main() {
    val scope = CoroutineScope(Dispatchers.Default)
    val liveEvent = LiveEventFlow<String>()

    // 订阅Flow：新订阅者只会收到订阅后的新值
    scope.launch {
        liveEvent.flow.collect {
            println("收到新值：$it")
        }
    }

    // 发射测试值
    scope.launch {
        liveEvent.emit("初始值")
        liveEvent.emit("更新值")
    }

    // 获取最后值
    Thread.sleep(100) // 等待值发射完成
    println("当前最后值：${liveEvent.getLastValue()}")
}

简化场景优化 #

如果你的业务场景是单线程环境（比如仅在Android主线程发射和获取值），可以去掉Mutex来简化代码，直接用普通变量存储最后值即可。

内容的提问来源于stack exchange，提问作者yaugenka