¿Cómo trabajas con la multitarea en Kotlin?

En Kotlin, para trabajar con la multitarea, principalmente utilizo corutinas. Ofrecen un enfoque más ligero y flexible en comparación con los hilos tradicionales, minimizando la sobrecarga y simplificando la gestión de operaciones paralelas.

Conceptos clave al trabajar con corutinas:

• Funciones Suspend: Funciones que pueden ser suspendidas y reanudadas. Son la base para operaciones asíncronas en corutinas.

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

• CoroutineScope: Define el ciclo de vida de las corutinas y permite gestionar su cancelación.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // CoroutineScope para ejecución bloqueante
      launch { // Crear una nueva corutina en este Scope
          // Código de la corutina
      }
  }
  

• Dispatchers (Planificadores): Definen el grupo de hilos en el que se ejecutará la corutina.
  • Dispatchers.Default: Para cálculos intensivos de CPU.
  • Dispatchers.IO: Para operaciones de I/O bloqueantes (por ejemplo, trabajo con redes, archivos).
  • Dispatchers.Main: Para trabajar con UI (disponible en plataformas correspondientes, por ejemplo, Android).
  • Dispatchers.Unconfined: No ligado a un grupo de hilos específico.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Cambio al planificador de I/O
          // Ejecución de operación bloqueante
      }
  }
  

• Constructores de corutinas: Funciones para lanzar corutinas.
  • launch: Inicia una corutina y devuelve un Job, que puede usarse para cancelarla.
  • async: Inicia una corutina y devuelve un Deferred, que permite obtener el resultado mediante await().

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Tarea paralela
      }
  
      val deferredResult = async {
          // Tarea que devuelve un resultado
          "Resultado"
      }
  
      job.cancel() // Cancelar la tarea
      val result = deferredResult.await() // Obtener resultado
  }
  

Para sincronizar el acceso a recursos compartidos, utilizo herramientas del paquete kotlinx.coroutines.sync, como Mutex o Semaphore.

import kotlinx.coroutines.*
import kotlinx.coroutines.sync.*

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Bloqueo del Mutex antes del acceso al recurso compartido
        counter++
    }
}

En algunos casos específicos, cuando se requiere control directo de los hilos a nivel bajo, puedo usar clases del paquete java.util.concurrent o directamente clases Thread y Runnable, aunque esto se usa mucho menos que las corutinas.

Ventajas de las corutinas en comparación con los hilos tradicionales:

Característica	Corutinas	Hilos tradicionales
Peso	Livianas, muchas en un solo hilo	Pesados, cada hilo ocupa recursos
Cambio	Cooperativo (suspend/resume)	Forzado (planificador del SO)
Cancelación	Fácil y estructurada	Compleja, requiere manejo de interrupciones
Depuración	Cómoda, se mantiene la traza de pila	Puede ser difícil
Estructura	Soportan concurrencia estructurada	Menos estructurados

Prefiero las corutinas por su eficiencia, simplicidad en la escritura de código asíncrono y mejor legibilidad, especialmente al trabajar con secuencias complejas de operaciones asíncronas.