Kotlin coroutine asynchronous flow

runBlocking

because launch Only in CoroutineScope In a statement

runBlocking Its name means the thread that runs it ( In this case, the main thread ) Blocked during call , until runBlocking All processes in {…} Complete their execution . You often see this at the top of your application runBlocking, This is rarely used in real code , Because threads are expensive resources , Blocking them is inefficient , And it is usually not desirable .

 runBlocking {
    
        launch {
    
            delay(1000)
            println("word!")
        }
        println("Helllo")
    }

Helllo
word!

extract launch{…} To a separate function

fun main(args: Array<String>) {
    
    runBlocking {
    
       launch {
     doWorld() }
        println("Helllo")
    }
}
suspend fun doWorld(){
    
    delay(1000)
    println("word!")
}

Helllo
word!

Used in any pending function coroutineScope

fun main(args: Array<String>) {
    
    runBlocking {
    
        doWorld()
    }
}

suspend fun doWorld() = coroutineScope {
    
    launch {
    
        delay(1000L)
        println("World!")
    }
    println("Hello")
}

Hello
World!

coroutineScope The builder can perform multiple concurrent operations

fun main(args: Array<String>) {
    
    runBlocking {
    
        doWorld()
        println("Done")
    }
}

suspend fun doWorld() = coroutineScope {
    
    launch {
    
        delay(2000L)
        println("World 2")
    }
    launch {
    
        delay(1000L)
        println("World 1")
    }
    println("Hello")
}

Hello
World 1
World 2
Don

Wait for the subprocess to complete , And then print “Done” character string

 runBlocking {
    
        val job = launch {
     // launch a new coroutine and keep a reference to its Job
            delay(1000L)
            println("World!")
        }
        println("Hello")
        job.join() // wait until child coroutine completes
        println("Done")
    }

Hello
World!
Done

Combine pending functions , After getting every condition , At the conclusion

fun main() = runBlocking<Unit> {
    
//sampleStart
    val time = measureTimeMillis {
    
        println("The answer is ${concurrentSum()}")
    }
    println("Completed in $time ms")
//sampleEnd    
}

suspend fun concurrentSum(): Int = coroutineScope {
    
    val one = async {
     doSomethingUsefulOne() }
    val two = async {
     doSomethingUsefulTwo() }
    one.await() + two.await()
}

suspend fun doSomethingUsefulOne(): Int {
    
    delay(1000L) //  Suppose we do something useful here 
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    
    delay(1000L) //  Suppose we do something useful here 
    return 29
}

The answer is 42
Completed in 1017 ms

Asynchronous flow Flow count down

@RequiresApi(Build.VERSION_CODES.N)
fun main(args: Array<String>) {
    
    runBlocking {
    
        launch {
    
            val ret = countdown(60_000, 2_000) {
     remianTime ->
                println(" The rest of the time $remianTime")
            }.onStart {
    
                println("countdown start")
            }.onCompletion {
    
                println("countdown end")
            }.reduce {
     acc, value ->
                println("acc$acc value $value ")
            }
            println("coutdown acc ret = $ret")
        }
    }
}

fun <T> countdown(
    duration: Long,
    interval: Long,
    onCountdown: suspend (Long) -> T
): Flow<T> = flow {
    
    (duration - interval downTo 0 step interval).forEach {
     emit(it) }
}.onEach {
     delay(interval) }
    .onStart {
     emit(duration) }
    .map {
     onCountdown(it) }
    .flowOn(Dispatchers.Default)

countdown start
 The rest of the time 60000
 The rest of the time 58000
acckotlin.Unit value kotlin.Unit 
 The rest of the time 56000
acckotlin.Unit value kotlin.Unit 
 The rest of the time 54000
........
acckotlin.Unit value kotlin.Unit 
 The rest of the time 2000
acckotlin.Unit value kotlin.Unit 
 The rest of the time 0
acckotlin.Unit value kotlin.Unit 
countdown end
coutdown acc ret = kotlin.Unit

Reference article ：https://book.kotlincn.net/text/flow.html
Kotlin asynchronous | Flow Application scenarios and principles https://juejin.cn/post/6989032238079803429