Como implementar multitarefa em Kotlin?

A multitarefa em Kotlin pode ser implementada de várias maneiras:

1. Fios padrão do Java (Threads):

   // Implementar a interface Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Código que será executado numa thread separada
           println("Olá do thread: ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Criar uma instância de Runnable
       val runnable = MyRunnable()
       // Criar um objeto Thread com Runnable
       val thread = Thread(runnable)
       // Iniciar a thread
       thread.start()
   }
   

   Ou usando uma expressão lambda:

   fun main() {
       val thread = Thread {
           // Código que será executado numa thread separada
           println("Olá do thread: ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Coroutines do Kotlin: É uma abordagem recomendada e mais moderna em Kotlin, que fornece uma multitarefa leve.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Criar uma nova coroutine no escopo global
       launch {
           delay(1000L) // Atraso não bloqueante de 1 segundo
           println("Olá da coroutine")
       }
       // O thread principal continua a trabalhar
       println("Olá do thread principal")
       // runBlocking espera que todas as coroutines filhas terminem
   }
   

   Exemplos de diferentes construtores de coroutines:

   • launch: Inicia uma nova coroutine sem valor de retorno.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Esta coroutine apenas realiza uma ação")
       }
   }
   

   • async: Inicia uma nova coroutine que retorna um resultado usando Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Resultado da coroutine"
       }
       val result = deferredResult.await() // Espera pelo resultado
       println(result)
   }
   

3. RxKotlin/RxJava: A programação reativa também permite trabalhar com operações assíncronas e multitarefa, usando agendadores (Schedulers).

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Elemento assíncrono")
           .subscribeOn(Schedulers.io()) // Inscrever-se no thread de E/S
           .observeOn(Schedulers.computation()) // Observar resultados no thread de computação
           .subscribe { item ->
               println("Recebido: $item no thread ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Esperar pela conclusão das operações assíncronas
   }
   

A escolha do método depende da tarefa específica. Para a maioria das aplicações modernas em Kotlin, as coroutines são preferidas devido à sua leveza, facilidade de uso e suporte embutido na linguagem. Os threads Java podem ser adequados para controle de baixo nível, e as bibliotecas reativas para trabalhar com fluxos de dados.