Como se pode trabalhar com multithreading em Kotlin?

Em Kotlin, a concorrência pode ser implementada de várias formas, cada uma com suas vantagens dependendo da tarefa:

1. Fios tradicionais da JVM (java.lang.Thread): Usamos diretamente a API Java.

   // Criar e iniciar um novo fio
   Thread {
       // Código que é executado em um fio separado
       println("Olá do fio!")
   }.start()
   

2. Executores (java.util.concurrent pacote): Gestão mais flexível dos pools de fios.

   // Uso de um pool de fios de tamanho fixo
   import java.util.concurrent.Executors
   
   val executor = Executors.newFixedThreadPool(4)
   
   executor.submit {
       // Tarefa para executar no pool
       println("Tarefa em execução no pool")
   }
   
   // Não esquecer de fechar o pool
   // executor.shutdown()
   

3. Corutinas (Kotlin Coroutines): Fios leves gerenciados pelo framework, que fornecem execução assíncrona e não bloqueante. São o método preferido no desenvolvimento moderno de Android.

   // Adicionando dependências kotlinx-coroutines-core e kotlinx-coroutines-android
   
   import kotlinx.coroutines.*
   
   // Iniciar uma corutina no escopo global
   GlobalScope.launch {
       delay(1000L) // Retardo não bloqueante
       println("Olá da corutina!")
   }
   
   // Exemplo de uso em ViewModel (para Android)
   /*
   import androidx.lifecycle.ViewModel
   import androidx.lifecycle.viewModelScope
   
   class MyViewModel : ViewModel() {
       fun doSomethingAsync() {
           viewModelScope.launch {
               // Código que funciona no escopo do ViewModel,
               // que é cancelado automaticamente ao limpar o ViewModel
           }
       }
   }
   */
   

Comparação de abordagens:

Abordagem	Gestão	Leveza	Gestão de erros	Cancelamento	Complexidade de uso (para tarefas típicas)
java.lang.Thread	Manual (criação, lançamento, gestão)	Pesado	Manual	Manual	Média
java.util.concurrent	Através da API de executores	Pesado	Através da API	Através da API	Média
Coroutines (Kotlin Coroutines)	Framework (escopos, contextos, despachadores)	Leve	Estruturado	Integrada	Baixa (para tarefas típicas)

As corutinas oferecem a forma mais conveniente e eficiente de trabalhar com código assíncrono no Android, minimizando problemas com a gestão do ciclo de vida e cancelamento de tarefas.