¿Qué mecanismos proporciona Kotlin para trabajar con cálculos paralelos?

• Corutinas (Coroutines): Hilos ligeros que permiten escribir código asíncrono en estilo imperativo, evitando llamadas bloqueantes. Se basan en funciones reanudables y no están vinculadas a hilos nativos.
• Dispatchers: Determinan el hilo o grupo de hilos en el que se ejecutará la corutina.
  • Dispatchers.Default: Para tareas que consumen muchos recursos (por ejemplo, CPU-bound).
  • Dispatchers.IO: Para operaciones de E/S (por ejemplo, solicitudes de red, trabajo con archivos).
  • Dispatchers.Main: Para ejecutar código en el hilo principal (por ejemplo, actualización de UI en una aplicación Android).
  • Dispatchers.Unconfined: Ejecuta la corutina en el hilo actual hasta la primera llamada a una función suspendida.
• Funciones suspend: Funciones que pueden ser pausadas y reanudadas más tarde. Se marcan con el modificador suspend.
• Contexto: Contiene información sobre la corutina, como el dispatcher, el job y el manejador de excepciones.
• Job: Representa el ciclo de vida de la corutina (en ejecución, activa, finalizada, cancelada). Permite gestionar la corutina (cancelar, esperar a que termine).
• Scope: Define el ámbito de las corutinas, gestionando su ciclo de vida.
• MutableStateFlow / SharedFlow: En la biblioteca kotlinx.coroutines.flow, permiten intercambiar datos de forma segura entre corutinas.
• Mutex: Primitive de sincronización para proteger secciones críticas.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Ejemplo de uso de corutinas y dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Corutina de trabajo: $i")
            delay(100) // Retardo no bloqueante
        }
    }
    println("Corutina lanzada")
    job.join() // Espera a que la corutina termine
    println("Corutina finalizada")
}

// Ejemplo de función suspend
suspend fun fetchData(): String {
    delay(1000) // Simulación de solicitud de red
    return "Datos recibidos"
}

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

val mutex = Mutex()
var counter = 0

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