Concurrencia de corrutina de Kotlin/conmutación en paralelo y en serie, CoroutineScope y await

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.Default).launch {
        // 并发执行
        this.launch {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.launch {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

La salida muestra que después de las salidas principales, ni A ni B salen. CoroutineScope(Dispatchers.IO).launch La nueva tarea no bloquea el proceso de ejecución de la tarea principal principal.

Si cambia a runBlocking (Dispatchers.IO):

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking(Dispatchers.IO) {
        // 并发执行
        this.launch {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.launch {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

mira asíncrono

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.IO).launch() {
        // 并发执行
        this.async {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.async {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    println("${LocalTime.now()} - main end")
}

Si el hilo principal descansa durante 1000 ms:

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    CoroutineScope(Dispatchers.IO).launch() {
        // 并发执行
        this.async {
            println("${LocalTime.now()} A start")
            delay(1000)
            println("${LocalTime.now()} A end")
        }

        this.async {
            println("${LocalTime.now()} B start")
            delay(1500)
            println("${LocalTime.now()} B end")
        }
    }

    Thread.sleep(1000)
    println("${LocalTime.now()} - main end")
}

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking {
        CoroutineScope(Dispatchers.IO).launch() {
            val task1 = this.async {
                println("${LocalTime.now()} A start")
                delay(1000)
                println("${LocalTime.now()} A end")

                "task1 return"
            }

            val task2 = this.async {
                println("${LocalTime.now()} B start")
                delay(1500)
                println("${LocalTime.now()} B end")

                "task2 return"
            }

            val t1 = task1.await()
            println("${LocalTime.now()} $t1")

            val t2 = task2.await()
            println("${LocalTime.now()} $t2")
        }
    }

    println("${LocalTime.now()} - main end")
}

En general, la importancia de CoroutineScope(Dispatchers.IO).launch() es iniciar un nuevo subproceso sin bloquear el subproceso principal principal, porque

entender esperar

import kotlinx.coroutines.*
import java.time.LocalTime

fun main(args: Array<String>) {
    println("${LocalTime.now()} - main start")

    runBlocking {
        //launch() {
            val task1 = this.async {
                println("${LocalTime.now()} A start")
                delay(3000)
                println("${LocalTime.now()} A end")

                "task1 return"
            }

            val task2 = this.async {
                println("${LocalTime.now()} B start")
                delay(1000)
                println("${LocalTime.now()} B end")

                "task2 return"
            }

            val t1 = task1.await()
            println("${LocalTime.now()} $t1")

            val t2 = task2.await()
            println("${LocalTime.now()} $t2")
        //}
    }

    println("${LocalTime.now()} - main end")
}

Aunque la tarea 2 se completa pronto, debido a la espera, debe esperar a que regrese la tarea 1.

kotlin coroutine async y await_zhangphil's blog-CSDN blog runBlocking inicia internamente 3 coroutines para realizar operaciones que consumen mucho tiempo. A partir de la salida, puede ver que los 3 coroutines se ejecutan simultáneamente. RunBlocking esperará hasta que se complete la ejecución de los 3 coroutines antes Los resultados de salida tienen una secuencia clara. Las técnicas generales de programación, por ejemplo, en Android, suponen que se implementa una función en el subproceso principal, pero esta función es una operación que consume mucho tiempo, no hay duda de que la implementación de esta función debe cortarse en un subproceso no principal. para la operación, puede diseñar una función administrada A que haga el trabajo sucio en la función administrada y arroje el resultado al subproceso principal una vez que se complete el procesamiento. Resultado 1-a: 5 - tid: 22. Resultado 1-b: 5 - tid: 24. Resultado 2-a: 9 - tid: 22. https://blog.csdn.net/zhangphil/article/details/129268399

https://zhangphil.blog.csdn.net/article/details/129265638 https://zhangphil.blog.csdn.net/article/details/129265638

Corrutinas de Kotlin, cambio de subprocesos, método de función blog-CSDN de entrustment_zhangphil runBlocking inicia internamente 3 corrutinas para realizar operaciones que consumen mucho tiempo, puede ver en la salida que 3 corrutinas se ejecutan simultáneamente y runBlocking esperará hasta que 3 corrutinas salgan después de la la ejecución se completa y los resultados de salida tienen una secuencia clara. Las técnicas generales de programación, por ejemplo, en Android, suponen que se implementa una función en el subproceso principal, pero esta función es una operación que consume mucho tiempo, no hay duda de que la implementación de esta función debe cortarse en un subproceso no principal. para la operación, puede diseñar una función administrada A que haga el trabajo sucio en la función administrada y arroje el resultado al subproceso principal una vez que se complete el procesamiento. Resultado 1-a: 5 - tid: 22. Resultado 1-b: 5 - tid: 24. Resultado 2-a: 9 - tid: 22. https://blog.csdn.net/zhangphil/article/details/130161705

https://zhangphil.blog.csdn.net/article/details/129250518 https://zhangphil.blog.csdn.net/article/details/129250518

Concurrencia de corrutina de Kotlin/conmutación en paralelo y en serie, CoroutineScope y await

Supongo que te gusta