Introducción a Coroutine en Kotlin

Jan 17 2023

Un Coroutine es un subproceso ligero de ejecución que se puede suspender y reanudar más tarde. Ya hay muchos artículos o temas que cubren esto, pero esta publicación es diferente, es simple y puede permitirle comenzar más fácilmente.

Descripción general

Al igual que muchos otros lenguajes de programación como JS, Python, Coroutine es una función proporcionada por Kotlin que nos permite realizar tareas largas y que consumen mucho tiempo. En breve:

En Kotlin, Coroutines es una forma de escribir código asíncrono y sin bloqueo de una manera más secuencial y fácil de leer.

De hecho, nada de nuevas técnicas aquí. Podemos tratar Kotlin Coroutine como un marco/biblioteca que encapsula algunos usos comunes al tratar con la asincronización.

Ejemplos simples de uso de rutinas en Kotlin

Para usar rutinas en Kotlin, debe incluir la kotlinx-coroutines-corebiblioteca en su proyecto. En el archivo gradle de su aplicación (solo hay un archivo gradle en el proyecto IntelliJ, o elija el archivo gradle para la aplicación si es un proyecto de Android), agregue la siguiente línea:

dependencies {
    testImplementation(kotlin("test-junit"))
    implementation(kotlin("stdlib-jdk8"))
    // add coroutine dependency
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2")
}

1. Úsalo `launch`para crear rutinas

Aquí hay un ejemplo del uso de una rutina para realizar una tarea de larga duración en segundo plano:

import kotlinx.coroutines.*

fun main() {
    // Start a coroutine using the launch function
    val job = GlobalScope.launch {
        // Perform a long-running task in the background
        delay(1000L)
        println("Hello, world!")
    }

    // Wait for the coroutine to finish
    runBlocking {
        job.join()
    }
}

2. Úsalo `async`para crear rutinas

Aquí hay un ejemplo del uso de rutinas en Kotlin para realizar múltiples tareas en paralelo y luego esperar a que todas terminen:

import kotlinx.coroutines.*

fun main() {
    // Start two coroutines using the async function
    val job1 = GlobalScope.async {
        // Perform a long-running task in the background
        delay(1000L)
        println("Task 1")
    }

    val job2 = GlobalScope.async {
        // Perform a different long-running task in the background
        delay(2000L)
        println("Task 2")
    }

    // Wait for both coroutines to finish
    runBlocking {
        job1.await()
        job2.await()
    }
}

La diferencia entre lanzamiento y asíncrono para iniciar una corrutina

Ambos se usan comúnmente para iniciar una rutina. La principal diferencia entre los dos es que launchdevuelve un trabajo (un futuro cancelable sin bloqueo) y no devuelve un resultado, mientras que asyncdevuelve un diferido (un futuro cancelable sin bloqueo con un resultado) que se puede utilizar para obtener el resultado de la rutina Teniendo en cuenta la diferencia, ¿cuándo debería usar el lanzamiento y async para crear rutinas?

Cuando usa launchla función, la corrutina se ejecutará en segundo plano y la llamada a la función regresará inmediatamente. Se utiliza cuando no se necesita el resultado de la rutina.
Cuando usa asyncla función, la corrutina también se ejecutará en segundo plano y la llamada a la función regresará inmediatamente, pero devolverá un Deferredobjeto en el que puede llamar a la función .await() para obtener el resultado de la corrutina. Se utiliza cuando se necesita el resultado de la rutina. Por ejemplo:

val result = GlobalScope.async {
        return@async URL("https://api.example.com/data").readText()
    }
val data = result.await()
println(data)
// output: {"fact":"A group of cats is called a \u201cclowder.\u201d","length":38}

¿Qué hay más de aquí? Como sabemos, Coroutine es un gran tema y pocos usuarios pueden explicarlo todo. Este es el primer artículo de la serie Coroutine. Si está interesado, suscríbase para recibir más publicaciones sobre esto: