Por que Coroutines? O problema da concorrência tradicional

Mergulhando nos fundamentos das Coroutines:

1. Funções suspend: a magia por trás das coroutines

suspend fun buscarDadosDaRede(): String {
    // ... código para fazer a requisição ...
    delay(1000) // Simulando uma operação demorada (não bloqueia a thread!)
    return "Dados recebidos!"
}

2. CoroutineScope: maestro da orquestra

val meuEscopo = CoroutineScope(Dispatchers.Main) // Cria um escopo ligado à thread principal

meuEscopo.launch { // Inicia uma nova Coroutine
    val dados = buscarDadosDaRede()
    println(dados) // Será executado depois que buscarDadosDaRede() terminar
}

// O código aqui continua executando *imediatamente*, sem esperar a Coroutine terminar!

3. CoroutineContext: os detalhes importantes

• Job: que controla o ciclo de vida da Coroutine. Permite que você cancele a Coroutine, verifique seu estado (ativa, cancelada, etc.) e aguarde sua conclusão.

• CoroutineDispatcher: que determina em qual thread (ou pool de threads) a Coroutine será executada.

4. CoroutineDispatcher: escolhendo a thread certa

launch(Dispatchers.IO) { // Executa em uma thread otimizada para operações de I/O
    val arquivo = lerArquivoDoDisco()
    // ...
}

launch(Dispatchers.Main) { // Executa na thread principal (UI)
    atualizarInterface(dados)
}

launch(Dispatchers.Default) { // Executa em uma thread otimizada para uso intensivo de CPU
    val resultado = calcularPi(1000000) //Calcula PI com 1 milhão de casas decimais
}

// Evite Dispatchers.Unconfined em produção! (A menos que você saiba *exatamente* o que está fazendo)

withContext(Dispatchers.Default.limitedParallelism(3)) {
   //Operação que será executada utilizando no máximo 3 threads
}

5. launch e async: iniciando coroutines

• launch: inicia uma Coroutine no estilo "dispare e esqueça" (fire-and-forget). Não retorna nenhum resultado.

• async: inicia uma Coroutine que retorna um resultado (um objeto Deferred).

val job = launch { // Inicia uma Coroutine, mas não retorna um resultado
    // ...
}

val resultado: Deferred<Int> = async { // Inicia uma Coroutine que retorna um Int
    // ...
    return 42
}

val valor = resultado.await() // Espera (suspende) até que o resultado esteja pronto

Indo Além: Coroutines em ação

Execução sequencial vs. paralela

// Sequencial:
suspend fun fazerTarefa1(): String { /* ... */ }
suspend fun fazerTarefa2(): Int { /* ... */ }

suspend fun executarSequencialmente() {
    val resultado1 = fazerTarefa1() // Espera fazerTarefa1() terminar
    val resultado2 = fazerTarefa2() // Espera fazerTarefa2() terminar
    println("$resultado1 - $resultado2")
}
// Paralela:
suspend fun executarParalelamente() = coroutineScope {
    val resultado1 = async { fazerTarefa1() } // Inicia fazerTarefa1() em paralelo
    val resultado2 = async { fazerTarefa2() } // Inicia fazerTarefa2() em paralelo
    println("${resultado1.await()} - ${resultado2.await()}") // Espera *ambas* terminarem
}

withContext: mudando de Dispatcher

suspend fun buscarDados() = withContext(Dispatchers.IO) {
    // Faz uma requisição à rede (operação de I/O)
    // ...
}

coroutineScope vs. supervisorScope

• coroutineScope: cria um novo escopo para Coroutines. Se uma das Coroutines filhas falhar, todas as outras serão canceladas.

• supervisorScope: cria um escopo que não cancela as outras Coroutines filhas se uma delas falhar. Use com cuidado!

suspend fun processarDados() = supervisorScope {
    val tarefa1 = launch { /* ... */ } // Se falhar, tarefa2 não será cancelada
    val tarefa2 = launch { /* ... */ }
}

withTimeout e withTimeoutOrNull

val resultado = withTimeoutOrNull(5000) { // Define um tempo limite de 5 segundos
    fazerOperacaoDemorada()
}

if (resultado == null) {
    // A operação demorou mais de 5 segundos e foi cancelada
}

Lidando com exceções

try-catch

try {
    val resultado = fazerOperacaoArriscada()
    // ...
} catch (e: IOException) {
    // Lidar com a exceção
}

CoroutineExceptionHandler

val handler = CoroutineExceptionHandler { _, exception ->
    println("Exceção capturada: $exception")
    // Fazer algo (por exemplo, exibir uma mensagem de erro)
}

val meuEscopo = CoroutineScope(Dispatchers.Main + handler) // Adiciona o handler ao escopo

meuEscopo.launch {
    // ... código que pode lançar exceções ...
}

SupervisorJob

val meuEscopo = CoroutineScope(SupervisorJob() + Dispatchers.Main)

meuEscopo.launch { /* ... */ } // Se esta Coroutine falhar, as outras não serão canceladas
meuEscopo.launch { /* ... */ }

Boas práticas e erros comuns

• Nunca use GlobalScope: ele cria Coroutines que não estão vinculadas a nenhum ciclo de vida e podem causar vazamentos de memória. Use viewModelScope, lifecycleScope ou crie seus próprios escopos.

• Não passe CoroutineScope como argumento: em vez disso, use funções suspensas e coroutineScope.

• Evite re-dispatching desnecessário: se você já estiver na thread correta (por exemplo, Dispatchers.Main), não use withContext(Dispatchers.Main) novamente. Use Dispatchers.Main.immediate para evitar o custo de mudar de thread se já estiver na thread principal.

• Cancele Coroutines quando não forem mais necessárias: use Job.cancel() para cancelar Coroutines explicitamente ou use escopos vinculados ao ciclo de vida para que elas sejam canceladas automaticamente.

• Use Mutex e AtomicReference para evitar condições de corrida em código multi-thread.

Próximos passos

• Documentação oficial do Kotlin: https://kotlinlang.org/docs/coroutines-overview.html

• Comece a praticar! Refatore o código do seu projeto.

• Explore tópicos avançados: Canais (Channels)