¿Cómo implementar la multitarea en Kotlin?

La multitarea en Kotlin se puede implementar de varias maneras:

1. Hilos estándar de Java (Threads):

   // Implementamos la interfaz Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Código que se ejecutará en un hilo separado
           println("Hola desde el hilo: ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Crear una instancia de Runnable
       val runnable = MyRunnable()
       // Crear un objeto Thread con Runnable
       val thread = Thread(runnable)
       // Iniciar el hilo
       thread.start()
   }
   

   O usando una expresión lambda:

   fun main() {
       val thread = Thread {
           // Código que se ejecutará en un hilo separado
           println("Hola desde el hilo: ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Corutinas de Kotlin: Es un enfoque recomendado y más moderno en Kotlin, que proporciona una multitarea ligera.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Crear una nueva corutina en el scope global
       launch {
           delay(1000L) // Retardo no bloqueante de 1 segundo
           println("Hola desde la corutina")
       }
       // El hilo principal continúa trabajando
       println("Hola desde el hilo principal")
       // runBlocking espera a que terminen todas las corutinas hijas
   }
   

   Ejemplos de diferentes constructores de corutinas:

   • launch: Inicia una nueva corutina sin valor de retorno.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Esta corutina simplemente realiza una acción")
       }
   }
   

   • async: Inicia una nueva corutina que devuelve un resultado usando Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Resultado de la corutina"
       }
       val result = deferredResult.await() // Espera el resultado
       println(result)
   }
   

3. RxKotlin/RxJava: La programación reactiva también permite trabajar con operaciones asíncronas y multitarea, usando planificadores (Schedulers).

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Elemento asíncrono")
           .subscribeOn(Schedulers.io()) // Suscribirse en el hilo de E/S
           .observeOn(Schedulers.computation()) // Observar resultados en el hilo de cálculo
           .subscribe { item ->
               println("Recibido: $item en el hilo ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Esperar a que terminen las operaciones asíncronas
   }
   

La elección del método depende de la tarea específica. Para la mayoría de las aplicaciones modernas en Kotlin, las corutinas son preferidas por su ligereza, facilidad de uso y soporte integrado en el lenguaje. Los hilos de Java pueden ser apropiados para un control de nivel inferior, y las bibliotecas reactivas para trabajar con flujos de datos.