Programação Assíncrona em Kotlin: Guia Completo

Introdução à programação assíncrona em Kotlin

Aplicativos modernos exigem alto desempenho e capacidade de resposta. A programação assíncrona em Kotlin é uma ferramenta poderosa que permite escrever código não bloqueante, utilizando eficientemente os recursos do sistema. Ao contrário do multithreading tradicional, as coroutines do Kotlin fornecem threads de execução leves que podem ser pausadas e retomadas sem bloquear a thread principal.

Neste guia, abordaremos os conceitos-chave da programação assíncrona em Kotlin: desde coroutines básicas até padrões avançados usando Flow e Channel. Você aprenderá a criar aplicações assíncronas eficientes que funcionarão de forma rápida e confiável.

Fundamentos das coroutines em Kotlin

O que é uma coroutine?

Uma coroutine é uma thread de execução leve que pode ser pausada em um ponto e retomada em outro. Em Kotlin, as coroutines são implementadas no nível da linguagem usando a palavra-chave suspend e builders especiais.

Iniciando a primeira coroutine

Para trabalhar com coroutines, é necessário adicionar a dependência no build.gradle.kts:

dependencies {    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")}

Exemplo básico de inicialização de uma coroutine:

import kotlinx.coroutines.*

fun main() = runBlocking {    launch {        delay(1000L)        println("Mundo!")    }    println("Olá,")}

Resultado da execução:

Olá,Mundo!

Funções Suspend

Funções Suspend são funções que podem pausar a execução de uma coroutine sem bloquear a thread. Elas são marcadas com a palavra-chave suspend:

suspend fun fetchUserData(): String {    delay(2000L) // simulação de requisição de rede    return "Dados do usuário"}

fun main() = runBlocking {    val data = fetchUserData()    println(data)}

Gerenciamento de coroutines: Scope e Dispatchers

CoroutineScope

CoroutineScope define o ciclo de vida das coroutines. Todas as coroutines são iniciadas dentro de um escopo específico. Se o escopo for cancelado, todas as suas coroutines filhas também serão canceladas.

class MyViewModel : ViewModel() {    private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())        fun loadData() {        scope.launch {            val data = fetchData()            updateUI(data)        }    }        override fun onCleared() {        super.onCleared()        scope.cancel()    }}

Dispatchers: escolha da thread de execução

Dispatchers determinam em qual pool de threads a coroutine será executada. Tipos principais:

• Dispatchers.Main — para a thread de UI (Android, JavaFX)
• Dispatchers.IO — para operações de entrada/saída (rede, arquivos)
• Dispatchers.Default — para tarefas intensivas de CPU
• Dispatchers.Unconfined — não vinculado a uma thread específica

fun main() = runBlocking {    launch(Dispatchers.IO) {        println("Executando no IO: ${Thread.currentThread().name}")    }    launch(Dispatchers.Default) {        println("Executando no Default: ${Thread.currentThread().name}")    }}

Técnicas avançadas: async/await e cancelamento de coroutines

Execução paralela com async

O builder async permite executar várias tarefas em paralelo e obter os resultados usando await():

suspend fun fetchDataFromApi1(): String {    delay(1000L)    return "Resultado API 1"}

suspend fun fetchDataFromApi2(): String {    delay(1500L)    return "Resultado API 2"}

fun main() = runBlocking {    val time = measureTimeMillis {        val result1 = async { fetchDataFromApi1() }        val