Why does binding `onEach` inside launch cause `MutableSharedFlow` events to be lost? - kotlin

Question

This test passes:
#Test
fun passingTest() {
val emitter = MutableSharedFlow<Int>();
var total = 0;
val handler = emitter.onEach { // <--- onEach bound outside of `launch`
total += it;
println("-> $it : total: $total")
}
GlobalScope.launch {
handler.collect()
}
runBlocking {
for (i in 1..11) {
emitter.emit(1);
}
}
assert(total == 11);
}
However, if I move the .onEach into launch it doesn't work any more:
> expected:<11> but was:<0>
> Expected :11
> Actual :0
#Test
fun failingTest() {
val emitter = MutableSharedFlow<Int>();
var total = 0;
GlobalScope.launch {
emitter.onEach { // <--- Bind inside of launch
total += it;
println("-> $it : total: $total")
}.collect()
}
runBlocking {
for (i in 1..11) {
emitter.emit(1);
}
}
assertEquals(11, total);
}
What's going on? Why is my onEach handler getting lost when it's attached inside the launch scope?

Answer 1

So I tried both test cases on my own, logging the blocks of GlobalScope.launch and runBlocking.
GlobalScope.launch {
println("launch")
handler.collect()
}
runBlocking {
for (i in 1..11) {
println(i)
emitter.emit(1);
}
}
println(total)
This test case gives me random output each run. E.g: "12345678910110" even without "launch", sometimes it works as it is expected, sometimes it start collecting after some values are already emitted and therefore the value of total is less than 11.
launch
1
2
-> 1 : total: 1
3
-> 1 : total: 2
4
-> 1 : total: 3
5
-> 1 : total: 4
6
-> 1 : total: 5
7
-> 1 : total: 6
8
-> 1 : total: 7
9
-> 1 : total: 8
10
-> 1 : total: 9
11
-> 1 : total: 10
-> 1 : total: 11
11
In the same time, running second test case several times did not get me to seeing ]total] greater than 0. But I noticed that GlobalScope code executes at random time, so I can see launch output before the output of runBlocking or in the middle of it, but onEach's output is not present still.
I decided to log collect call itself
GlobalScope.launch {
println("launch")
emitter.onEach {
total += it;
println("-> $it : total: $total")
}.collect {
"collecting"
}
}
And noticed that it does not get called at all. Since the time, at which code of GlobalScope.launch gets called, does not matter, I bet that the scope of handler matters.
onEach works as a listener, therefore emitting in runBlocking updates it in the first test case sometimes. And when collect gets called in the right time, it does collecting.
But the listening cannot happen in the other scope and therefore in the second case you will always receive an empty flow. If you add one more GlobalScope.launch with emitting something in the second case, it will get processed by handler and collected.