Métodos Utilitários e de Execução no Kotlin: Trabalhando com Corrotinas

1 – Introdução Ao trabalhar com corrotinas no Kotlin, existem métodos utilitários e métodos de execução que ajudam a gerenciar tarefas assíncronas de forma eficiente. Esses métodos são ferramentas essenciais para controlar: O tempo de execução das tarefas. O contexto em que as tarefas são executadas. O início e a sincronização de múltiplas corrotinas. Neste artigo, exploraremos os métodos mais importantes, como withTimeout, withContext, launch, async, e outros, com exemplos práticos para entender como e quando usá-los. 2 – Métodos Utilitários 2.1 – withTimeout O que é? Cancela a execução de um bloco de código se o tempo limite for atingido. Quando usar? Para evitar que tarefas assíncronas fiquem presas indefinidamente. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { try { withTimeout(1000) { // Tempo limite de 1 segundo delay(2000) // Simula uma tarefa longa println("Tarefa concluída!") } } catch (e: TimeoutCancellationException) { println("Tempo limite atingido! Tarefa cancelada.") } } 2.2 - withTimeoutOrNull O que é? Semelhante ao withTimeout, mas em vez de lançar uma exceção, retorna null se o tempo limite for atingido. Quando usar? Para evitar o uso de exceções e lidar com o timeout de forma mais controlada. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { val resultado = withTimeoutOrNull(1000) { // Tempo limite de 1 segundo delay(2000) // Simula uma tarefa longa "Tarefa concluída!" } if (resultado == null) { println("Tempo limite atingido! Retornou null.") } else { println(resultado) } } 2.3 – withContext O que é? Altera o contexto da corrotina (ex.: muda o dispatcher). Quando usar? Para trocar o dispatcher de forma temporária dentro de uma corrotina. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { println("Executando no Dispatcher Padrão: ${Thread.currentThread().name}") withContext(Dispatchers.IO) { println("Executando no Dispatcher IO: ${Thread.currentThread().name}") } println("De volta ao Dispatcher Padrão: ${Thread.currentThread().name}") } 2.4 – delay O que é? Suspende a execução de uma corrotina por um período de tempo, sem bloquear a thread. Quando usar? Para simular tarefas demoradas ou esperar por uma resposta. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { println("Iniciando a tarefa...") delay(1000) // Suspende por 1 segundo println("Tarefa concluída!") } 2.5 – yield O que é? Cede o contexto atual, permitindo que outras corrotinas sejam executadas. Quando usar? Para melhorar a cooperação entre corrotinas e evitar bloqueios desnecessários. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { launch { repeat(3) { i -> println("Corrotina 1 - Iteração $i") yield() // Cede o contexto } } launch { repeat(3) { i -> println("Corrotina 2 - Iteração $i") yield() // Cede o contexto } } } 3 – Métodos de Execução 3.1 – launch O que é? Cria uma nova corrotina e inicia sua execução imediatamente. Quando usar? Quando você não precisa retornar um resultado da corrotina. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { launch { println("Corrotina iniciada!") delay(1000) println("Corrotina finalizada!") } } 3.2 – async O que é? Cria uma nova corrotina que retorna um valor (deferred). Quando usar? Para tarefas assíncronas que retornam resultados. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { val resultado = async { delay(1000) "Resultado calculado!" } println("Esperando o resultado...") println("Resultado: ${resultado.await()}") } 3.3 – runBlocking O que é? Executa corrotinas em uma função bloqueante. Quando usar? Apenas em casos específicos, como scripts pequenos ou para testes rápidos. Exemplo: import kotlinx.coroutines.* fun main() = runBlocking { println("Iniciando runBlocking") delay(1000) println("Finalizando runBlocking") } 4 – Comparação: Métodos Utilitários vs. Métodos de Execução Aspecto Métodos Utilitários Métodos de Execução Função principal Controlar tempo, contexto e suspensão. Iniciar e gerenciar corrotinas. Retorno de valor Geralmente, não retornam valores. Alguns retornam valores (ex.: async). Exemplos principais withTimeout, delay, yield. launch, async, runBlocking. 5 – Conclusão Os métodos utilitários e de execução são ferramentas indispensáveis no ecossistema de corrotinas do Kotlin. Eles permitem que você controle a execução assíncrona de maneira precisa, escalável

Mar 6, 2025 - 09:25

Métodos Utilitários e de Execução no Kotlin: Trabalhando com Corrotinas

1 – Introdução

Ao trabalhar com corrotinas no Kotlin, existem métodos utilitários e métodos de execução que ajudam a gerenciar tarefas assíncronas de forma eficiente. Esses métodos são ferramentas essenciais para controlar:

O tempo de execução das tarefas.
O contexto em que as tarefas são executadas.
O início e a sincronização de múltiplas corrotinas.

Neste artigo, exploraremos os métodos mais importantes, como withTimeout, withContext, launch, async, e outros, com exemplos práticos para entender como e quando usá-los.

2 – Métodos Utilitários

2.1 – withTimeout

O que é? Cancela a execução de um bloco de código se o tempo limite for atingido.
Quando usar? Para evitar que tarefas assíncronas fiquem presas indefinidamente.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    try {
        withTimeout(1000) { // Tempo limite de 1 segundo
            delay(2000) // Simula uma tarefa longa
            println("Tarefa concluída!")
        }
    } catch (e: TimeoutCancellationException) {
        println("Tempo limite atingido! Tarefa cancelada.")
    }
}

2.2 - withTimeoutOrNull

O que é? Semelhante ao withTimeout, mas em vez de lançar uma exceção, retorna null se o tempo limite for atingido.
Quando usar? Para evitar o uso de exceções e lidar com o timeout de forma mais controlada.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val resultado = withTimeoutOrNull(1000) { // Tempo limite de 1 segundo
        delay(2000) // Simula uma tarefa longa
        "Tarefa concluída!"
    }

    if (resultado == null) {
        println("Tempo limite atingido! Retornou null.")
    } else {
        println(resultado)
    }
}

2.3 – withContext

O que é? Altera o contexto da corrotina (ex.: muda o dispatcher).
Quando usar? Para trocar o dispatcher de forma temporária dentro de uma corrotina.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Executando no Dispatcher Padrão: ${Thread.currentThread().name}")

    withContext(Dispatchers.IO) {
        println("Executando no Dispatcher IO: ${Thread.currentThread().name}")
    }

    println("De volta ao Dispatcher Padrão: ${Thread.currentThread().name}")
}

2.4 – delay

O que é? Suspende a execução de uma corrotina por um período de tempo, sem bloquear a thread.
Quando usar? Para simular tarefas demoradas ou esperar por uma resposta.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Iniciando a tarefa...")
    delay(1000) // Suspende por 1 segundo
    println("Tarefa concluída!")
}

2.5 – yield

O que é? Cede o contexto atual, permitindo que outras corrotinas sejam executadas.
Quando usar? Para melhorar a cooperação entre corrotinas e evitar bloqueios desnecessários.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        repeat(3) { i ->
            println("Corrotina 1 - Iteração $i")
            yield() // Cede o contexto
        }
    }

    launch {
        repeat(3) { i ->
            println("Corrotina 2 - Iteração $i")
            yield() // Cede o contexto
        }
    }
}

3 – Métodos de Execução

3.1 – launch

O que é? Cria uma nova corrotina e inicia sua execução imediatamente.
Quando usar? Quando você não precisa retornar um resultado da corrotina.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Corrotina iniciada!")
        delay(1000)
        println("Corrotina finalizada!")
    }
}

3.2 – async

O que é? Cria uma nova corrotina que retorna um valor (deferred).
Quando usar? Para tarefas assíncronas que retornam resultados.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val resultado = async {
        delay(1000)
        "Resultado calculado!"
    }

    println("Esperando o resultado...")
    println("Resultado: ${resultado.await()}")
}

3.3 – runBlocking

O que é? Executa corrotinas em uma função bloqueante.
Quando usar? Apenas em casos específicos, como scripts pequenos ou para testes rápidos.
Exemplo:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Iniciando runBlocking")
    delay(1000)
    println("Finalizando runBlocking")
}

4 – Comparação: Métodos Utilitários vs. Métodos de Execução

Aspecto	Métodos Utilitários	Métodos de Execução
Função principal	Controlar tempo, contexto e suspensão.	Iniciar e gerenciar corrotinas.
Retorno de valor	Geralmente, não retornam valores.	Alguns retornam valores (ex.: `async`).
Exemplos principais	`withTimeout`, `delay`, `yield`.	`launch`, `async`, `runBlocking`.

5 – Conclusão

Os métodos utilitários e de execução são ferramentas indispensáveis no ecossistema de corrotinas do Kotlin. Eles permitem que você controle a execução assíncrona de maneira precisa, escalável e eficiente.

Resumo dos Métodos:

1. Utilitários:

Controle de tempo: withTimeout, withTimeoutOrNull.
Contexto: withContext.
Suspensão: delay, yield.

1. Execução:

launch para corrotinas que não retornam valores.
async para corrotinas que retornam resultados.
runBlocking para executar corrotinas em scripts ou testes simples.

No próximo artigo, exploraremos como testar corrotinas e fluxos de maneira eficiente com ferramentas nativas e bibliotecas como o Turbine.

Referência
Documentação oficial do Kotlin sobre corrotinas