Crear y ejecutar coroutines en Kotlin

1. Corrutinas en Kotlin
2. Crear un nuevo proyecto y agregar dependencias en Kotlin
3. Crea y Ejecuta Corrutinas Secuencialmente en Kotlin
4. Crear y ejecutar coroutines simultáneamente en Kotlin
5. Conclusión

Este tutorial presentará rutinas y mostrará cómo se pueden ejecutar de forma secuencial o simultánea usando async- await() en Kotlin.

Corrutinas en Kotlin

Una rutina puede verse como un procedimiento, excepto que admite la programación asíncrona en comparación con otros procedimientos normales que solo admiten la programación síncrona.

La programación asíncrona es una técnica mediante la cual podemos suspender la ejecución de una tarea en un punto determinado y delegar la ejecución a otra tarea mientras la tarea suspendida espera a que se ejecuten algunas tareas en segundo plano. Estas tareas en segundo plano pueden incluir la lectura de un registro de una base de datos, la descarga del contenido de una página web y el procesamiento de una solicitud de usuario desde una aplicación.

En la programación síncrona, la ejecución de una tarea no se suspende en ningún momento, y el hilo se usa exclusivamente hasta que se completa la ejecución.

Una rutina representa esta instancia de una rutina suspendida. También se puede ver como un subproceso, pero una rutina no depende del subproceso subyacente, ya que puede pausar y reanudar la ejecución en diferentes subprocesos.

En este tutorial, aprenderemos a crear corrutinas secuenciales y concurrentes asegurándonos de que las funciones async- await() se ejecuten en el orden correcto.

Crear un nuevo proyecto y agregar dependencias en Kotlin

Vaya a IntelliJ y seleccione Archivo > Nuevo > Proyecto. En la ventana que se abre, ingrese kotlinCoroutines como nombre del proyecto, elija Kotlin en la sección Idioma, Gradle en la sección Sistema de compilación y presione el botón Create.

Para trabajar con corrutinas en Kotlin, debemos agregar las dependencias de corrutinas a nuestra aplicación. Vaya al archivo build.gradle.kts y asegúrese de tener las siguientes dependencias.

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2")
    testImplementation(kotlin("test"))
}

Asegúrese de tener una conexión a Internet activa para descargar las dependencias. Una vez descargadas las dependencias, carga los cambios de Gradle y continúa con los siguientes pasos.

Crea y Ejecuta Corrutinas Secuencialmente en Kotlin

Crea el paquete com/coroutine dentro de la carpeta kotlin, que será el paquete base de nuestra aplicación. Cree un archivo Main.kt en la carpeta coroutine, y copie y pegue el siguiente código en el archivo.

package com.coroutine

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

fun main(): Unit = runBlocking {
    val value = async {
        executeProcedureOne()
    }
    value.await()
    val secondValue = async {
        executeProcedureTwo()
    }
    secondValue.await()
}

En el código anterior, hemos definido dos métodos, executeProcedureOne() y executeProcedureTwo(), que pueden suspenderse para realizar algunas tareas en segundo plano. Esto se realiza utilizando la palabra clave suspender, como se muestra arriba.

Tenga en cuenta que estos dos métodos se pueden suspender sin bloquear el subproceso subyacente.

Hemos asignado la función principal a una función llamada runBlocking. La función runBlocking es una función constructora que crea una corrutina que se ejecuta en el subproceso principal y se bloquea hasta que las corrutinas dentro de la función hayan terminado de ejecutarse.

Dentro de la función runBlocking, hemos creado dos funciones async que llaman a los métodos executeProcedureOne() y executeProcedureTwo(), respectivamente.

La función async es un generador de corrutinas que crea una nueva corrutina y devuelve un Deferred. Un Deferred es un futuro que representa una promesa de devolver un valor, y podemos usar await() para recuperar el valor.

Tenga en cuenta que llamar a await() inmediatamente después de async hará que la rutina se suspenda ya que la rutina interna se está ejecutando y se reanuda una vez que finaliza.

El código anterior se ejecuta secuencialmente como los métodos await() después de que cada función async obligue a suspender la rutina hasta que se complete y pueda ir a las otras rutinas.

Ejecute el código anterior y tenga en cuenta que executeProcedureOne() se completa antes que executeProcedureTwo() incluso si demora más tiempo. La salida es como se muestra a continuación.

procedure one executed
procedure two executed

Crear y ejecutar coroutines simultáneamente en Kotlin

Comente el código anterior y copie y pegue el siguiente código en el archivo Main.kt justo después del comentario.

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

suspend fun executeProcedures() = coroutineScope{
    val firstValue = async {
        executeProcedureOne()
    }

    val secondValue = async {
        executeProcedureTwo()
    }

    firstValue.await()
    secondValue.await()
}

fun main(): Unit = runBlocking  {
    executeProcedures()
}

Hemos modificado el ejemplo anterior para que sea concurrente moviendo los constructores de rutinas async a otra función suspendible que tenga un coroutineScope y await() después de ejecutar las funciones para evitar la suspensión de una rutina.

La diferencia entre coroutineScope y runBlocking es que coroutineScope se suspende y libera el subproceso subyacente para continuar ejecutando otras tareas.

Ejecute el código anterior y tenga en cuenta que el método executeProcedureTwo() se ejecuta primero ya que tiene menos retraso que el método executeProcedureOne(). La salida se muestra a continuación.

procedure two executed
procedure one executed

Conclusión

En este tutorial, hemos aprendido qué son las corrutinas y cómo ejecutarlas de forma secuencial o simultánea aprovechando las funciones async- await(). También hemos aprendido varios conceptos comunes en el contexto de las rutinas, incluida la programación asíncrona, la programación síncrona, la función runBlocking{} y la función coroutineScope{}.