Como você trabalha com multitarefa em Kotlin?

No Kotlin, para trabalhar com multitarefa, uso principalmente corutinas. Elas oferecem uma abordagem mais leve e flexível em comparação com threads tradicionais, minimizando a sobrecarga e simplificando a gestão de operações paralelas.

Conceitos-chave ao trabalhar com corutinas:

• Funções Suspend: Funções que podem ser suspensas e retomadas. São a base para operações assíncronas em corutinas.

  suspend fun fetchData(): String {
      delay(1000) // Exemplo de suspensão
      return "Dados recebidos"
  }
  

• CoroutineScope: Define o ciclo de vida das corutinas e permite gerenciar sua cancelamento.

  import kotlinx.coroutines.*
  
  fun main() = runBlocking { // CoroutineScope para execução bloqueante
      launch { // Criação de uma nova corutina neste Scope
          // Código da corutina
      }
  }
  

• Dispatchers (Planificadores): Definem o grupo de threads no qual a corutina será executada.
  • Dispatchers.Default: Para cálculos intensivos de CPU.
  • Dispatchers.IO: Para operações de I/O bloqueantes (por exemplo, trabalho com redes, arquivos).
  • Dispatchers.Main: Para trabalhar com UI (disponível em plataformas correspondentes, por exemplo, Android).
  • Dispatchers.Unconfined: Não ligado a um grupo de threads específico.

  import kotlinx.coroutines.*
  
  suspend fun doSomethingAsync() {
      withContext(Dispatchers.IO) { // Mudança para o dispatcher de I/O
          // Execução de operação bloqueante
      }
  }
  

• Construtores de corutinas: Funções para lançar corutinas.
  • launch: Inicia uma corutina e retorna um Job, que pode ser usado para cancelamento.
  • async: Inicia uma corutina e retorna um Deferred, que permite obter o resultado usando await().

  import kotlinx.coroutines.*
  
  suspend fun example() {
      val job = launch {
          // Tarefa paralela
      }
  
      val deferredResult = async {
          // Tarefa que retorna resultado
          "Resultado"
      }
  
      job.cancel() // Cancelar tarefa
      val result = deferredResult.await() // Obter resultado
  }
  

Para sincronizar o acesso a recursos compartilhados, uso ferramentas do pacote kotlinx.coroutines.sync, como Mutex ou Semaphore.

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Bloqueio do Mutex antes do acesso ao recurso compartilhado
        counter++
    }
}

Em alguns casos específicos, quando é necessário controle direto de threads em nível baixo, posso usar classes do pacote java.util.concurrent ou diretamente classes Thread e Runnable, embora isso seja muito menos comum do que corutinas.

Vantagens das corutinas em comparação com threads tradicionais:

Característica	Corutinas	Threads tradicionais
Peso	Leves, muitas em um único thread	Pesados, cada thread ocupa recursos
Mudança	Cooperativo (suspend/resume)	Forçado (planificador do SO)
Cancelamento	Fácil e estruturado	Complexo, requer tratamento de interrupções
Depuração	Confortável, a rastreabilidade da pilha é mantida	Pode ser difícil
Estrutura	Suportam concorrência estruturada	Menos estruturados

Prefiro as corutinas pela sua eficiência, simplicidade na escrita de código assíncrono e melhor legibilidade, especialmente ao trabalhar com sequências complexas de operações assíncronas.