Kotlin Flow中CoroutineContext变更机制及flow builder使用疑问

使用flow构建器时，生产者不能在不同的CoroutineContext中发射值。因此，不要通过创建新协程或使用withContext代码块在不同CoroutineContext中调用emit，这种情况下可使用callbackFlow等其他Flow构建器。

我不清楚这段说明的具体含义，在我的场景中ViewModel同时包含生产者数据源和Flow构建器，是否意味着生产者与Flow构建器必须处于同一CoroutineContext？

MainActivity代码 #

class MainActivity : AppCompatActivity() {
    lateinit var textview:TextView
    lateinit var button:Button
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        textview = findViewById<TextView>(R.id.textview)

        var viewModel = viewModel()

        button = findViewById<Button>(R.id.button)
        viewModel.setupFlow()

        viewModel.setupFlow()
        setupClicks()
    }

    private fun setupClicks() {
        button.setOnClickListener {
            CoroutineScope(Dispatchers.Main).launch {
                Log.d("CONTEXT", "${coroutineContext.toString()} Main")
                flow
                    .catch { exception -> textview.text = "$exception" }
                    .collect {
                        Log.d("TAG", it.toString())
                        textview.text = it.toString()
                    }
            }
        }
    }

    companion object{
        lateinit var flow: Flow<Int>
    }
}

ViewModel代码 #

class viewModel: ViewModel() {
    fun setupFlow() {
        MainActivity.flow= flow {
            Log.d("TAG", "Start flow")
            (0..10).forEach {
                Log.d("TAG", "Emitting $it")
                Log.d("CONTEXT" , "${currentCoroutineContext().toString()} VM")
                emit(it)
                delay(500)
            }
        }.map {
            it * 10
        }.flowOn(Dispatchers.IO)
    }
}

问题解答 #

官方说明的核心含义 #

flow构建器是单协程上下文绑定的——它内部的emit调用必须始终在创建这个flow的协程上下文中执行。如果在flow代码块里，用withContext切换到其他上下文，或者启动新协程（比如launch/async）并在里面调用emit，就会触发异常，因为这违反了flow的线程安全约定。

你的场景分析 #

你的ViewModel代码是符合规则的：

• 你用flowOn(Dispatchers.IO)指定了整个flow上游（包括flow构建器和map操作）的执行上下文，这是合法的——flowOn是Flow官方提供的切换上下文的方式，它会把上游的所有操作调度到指定上下文，而emit始终在这个上下文里执行，没有跨上下文调用emit的情况。
• 你在flow构建器里的emit都是在flowOn指定的Dispatchers.IO上下文中执行的，没有切换到其他上下文调用emit，所以完全符合官方说明的要求。

误区澄清 #

官方说的“不能在不同CoroutineContext中发射值”，不是指生产者和收集器必须同上下文，而是指flow构建器内部的emit操作不能跳转到其他上下文执行。收集器（MainActivity里的collect）可以在任意上下文（比如你用的Dispatchers.Main），这是完全允许的——Flow本身就是设计用来在不同上下文之间传递数据的。

额外优化建议 #

1. 不要用MainActivity的伴生对象持有Flow，这种写法易引发内存泄漏，ViewModel应自行持有Flow并通过暴露属性的方式提供给Activity：

class ViewModel: ViewModel() {
    private val _flow = flow {
        Log.d("TAG", "Start flow")
        (0..10).forEach {
            Log.d("TAG", "Emitting $it")
            Log.d("CONTEXT" , "${currentCoroutineContext().toString()} VM")
            emit(it)
            delay(500)
        }
    }.map {
        it * 10
    }.flowOn(Dispatchers.IO)

    val flow: Flow<Int> = _flow
}

2. Activity中建议用lifecycleScope收集Flow，避免手动创建CoroutineScope导致的内存泄漏：

private fun setupClicks() {
    button.setOnClickListener {
        lifecycleScope.launch {
            viewModel.flow
                .catch { exception -> textview.text = "$exception" }
                .collect {
                    Log.d("TAG", it.toString())
                    textview.text = it.toString()
                }
        }
    }
}

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