¿Cuáles son las clases principales en Kotlin…

Clases y conceptos principales en Kotlin Coroutines:

CoroutineScope: Define el ciclo de vida de las corutinas lanzadas dentro de él. Permite cancelar todas las corutinas hijas.
Job: Representa un handle a una corutina. Permite rastrear su estado, esperar a que termine, cancelarla.
Deferred: Un tipo especial de Job que representa un valor que estará disponible más tarde. Se usa para cálculos asíncronos que devuelven un resultado. El resultado se obtiene con la función .await().
Dispatcher: Define el hilo o grupo de hilos en el que se ejecuta la corutina. Los principales despachadores:
- Dispatchers.Default: Optimizado para tareas intensivas en CPU. Usa un grupo de hilos compartido.
- Dispatchers.IO: Optimizado para operaciones de I/O (red, disco). Usa una cantidad adecuada de hilos.
- Dispatchers.Main: El hilo principal de UI. Para actualizar la interfaz de usuario. Disponible en plataformas Android y otras con la dependencia adecuada.
- Dispatchers.Unconfined: Ejecuta la corutina en el hilo actual, pero la reanuda en cualquier hilo que reanude la función suspending.
Suspending function: Función marcada con la palabra clave suspend que puede ser suspendida y reanudada más tarde. Puede llamar a otras funciones suspending.
runBlocking: Bloquea el hilo actual hasta que todas las corutinas en su ámbito hayan terminado. Se usa principalmente para pruebas y en funciones main.
launch: Inicia una nueva corutina sin bloquear el hilo actual y devuelve un Job.
async: Inicia una nueva corutina sin bloquear el hilo actual y devuelve un Deferred.

Ejemplo de uso:

// Ejemplo de uso de CoroutineScope, launch y Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Creación de CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Lanzar una corutina en el despachador IO
    val job: Job = scope.launch {
        // Realizar una solicitud de red u otra operación de I/O
        delay(1000) // Simulación de trabajo
        println("Corutina terminada en ${Thread.currentThread().name}")
    }

    // Esperar a que termine la corutina
    job.join()
    println("Función main terminada")
}

// Ejemplo de uso de async y Deferred
import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredSum: Deferred<Int> = async {
        delay(500)
        1 + 1
    }

    // Esperar el resultado
    val result = deferredSum.await()
    println("El resultado es: $result")
}

¿Cuáles son las clases principales en Kotlin Coroutines?