¿Qué elementos de multitarea proporciona Kotlin…

Kotlin proporciona los siguientes elementos de concurrencia:

Corutinas: Hilos ligeros basados en funciones suspendidas. Permiten la ejecución asíncrona y no bloqueante del código.

Constructores de corutinas: Funciones que inician corutinas. Los principales son: launch (inicia una corutina sin devolver valor), async (inicia una corutina y devuelve un Deferred, que puede ser esperado para obtener el resultado).

// Ejemplo de uso de launch
GlobalScope.launch {
    println("Hola desde la corutina ${Thread.currentThread().name}")
}

// Ejemplo de uso de async
val deferred = GlobalScope.async {
    delay(1000) // Simula una operación larga
    "Resultado"
}
val result = runBlocking { deferred.await() } // Espera el resultado

Dispatchers: Determinan en qué grupo de hilos se ejecutará la corutina. Los principales son:
- Dispatchers.Default: Grupo de hilos general para tareas intensivas en CPU.
- Dispatchers.IO: Grupo de hilos para operaciones de entrada/salida bloqueantes (trabajo con archivos, red).
- Dispatchers.Main: Dispatcher para el hilo de la interfaz de usuario en plataformas correspondientes (Android, Swing).
- Dispatchers.Unconfined: La corutina se inicia en el hilo actual, pero puede reanudarse en cualquier hilo.
```
GlobalScope.launch(Dispatchers.IO) {
    // Ejecución de entrada/salida
}
```
runBlocking: Función constructor de corutinas que bloquea el hilo actual hasta que la corutina finalice. Se usa para combinar código bloqueante y no bloqueante, a menudo en pruebas o funciones main.
```
runBlocking {
    launch {
        delay(500)
        println("Finalizado en ${Thread.currentThread().name}")
    }
    println("Iniciado en ${Thread.currentThread().name}")
}
```
Funciones suspend: Funciones cuyo ejecución puede ser suspendida y reanudada. Solo pueden ser llamadas desde otras funciones suspend o constructores de corutinas.
```
suspend fun doSomething() {
    delay(100) // Ejemplo de suspensión
}
```

Job: Handle para una corutina en ejecución. Proporciona métodos para gestionar el ciclo de vida de la corutina (cancelar, esperar a que termine).

val job = GlobalScope.launch {
   // Operación larga
}
job.cancel() // Cancela la corutina
runBlocking { job.join() } // Espera a que termine

CoroutineScope: Define un ámbito para las corutinas. Las corutinas lanzadas en un ámbito determinado se cancelan automáticamente al cancelar el ámbito. Ayuda a gestionar el ciclo de vida de las corutinas.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Corutina en este ámbito
}
scope.cancel() // Cancela todas las corutinas en este ámbito
```

Canales (Channel): Primitive para la transmisión segura de datos entre corutinas. Los canales pueden ser unidireccionales (solo enviar o recibir) o bidireccionales.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Es importante cerrar el canal
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutex (Mutex): Primitive de sincronización para garantizar acceso exclusivo a un recurso compartido. Garantiza seguridad en hilos, permitiendo que solo una corutina tenga el mutex en un momento dado.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Estados (StateFlow, SharedFlow): Primitive para trabajar con flujos de datos en el contexto de programación reactiva y concurrencia. StateFlow representa un flujo "frío" con el estado actual, y SharedFlow un flujo "caliente" para difusión de datos.

¿Qué elementos de multitarea proporciona Kotlin?