I run the Code A and get the Result A. In my mind, it should be the Result B.

It seems that flow.collect { value -> println(value) } block to execute.

Will the collect of the Flow block to execute ?

Code A

fun simple(): Flow<Int> = flow { 
    println("Flow started")
    for (i in 1..3) {
        delay(300)
        emit(i)
    }
}

fun main() = runBlocking<Unit> {
    println("Calling simple function...")
    val flow = simple()
    println("Calling collect...")
    flow.collect { value -> println(value) } //Block?
    println("Calling collect again...")   
}

Result A

Calling simple function...
Calling collect...
Flow started
1
2
3
Calling collect again...

Result B

Calling simple function...
Calling collect...
Flow started
Calling collect again...
1
2
3

BTW, I run Code 1 and get the result 1 as I expected.

Code 1

fun simple(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100) 
        emit(i) 
    }
}

fun main() = runBlocking<Unit> {  
    launch {
        for (k in 1..3) {
            println("I'm not blocked $k")
            delay(100)
        }
    }  
    simple().collect { value -> println(value) } 
}

Result 1

I'm not blocked 1
1
I'm not blocked 2
2
I'm not blocked 3
3

CodePudding user response：

Suspend functions do not block, but they are synchronous, meaning the execution of the code in the coroutine waits for the suspend function to return before continuing. The difference between suspend function calls and blocking function calls is that the thread is released to be used for other tasks while the coroutine is waiting for the suspend function to return.

collect is a suspend function that internally calls its lambda repeatedly and synchronously (suspending, not blocking) and doesn't return until the Flow is completed.

launch is an asynchronous function that starts a coroutine. It returns immediately without waiting for its coroutine to complete, which is why Code 1 behaved as you expected.