Filas de tarefas em Kotlin: Coroutines, Flow e bibliotecas para processamento em segundo plano

Filas de tarefas para Kotlin: processamento eficiente em segundo plano

No desenvolvimento moderno com Kotlin (especialmente para Android, backend com Ktor ou Spring), é frequentemente necessário organizar a execução de tarefas em segundo plano sem bloquear a thread principal. Para isso, são utilizadas filas de tarefas — mecanismos que permitem enfileirar operações e executá-las sequencialmente ou concorrentemente. Em Kotlin, o suporte nativo a coroutines fornece ferramentas poderosas para isso: Channel, Flow e dispatchers. Além disso, existem bibliotecas especializadas, como Kjob e Kotlinx-coroutines, que simplificam o gerenciamento de tarefas.

Neste artigo, abordaremos as principais abordagens para criar filas de tarefas em Kotlin, suas vantagens e forneceremos exemplos práticos de código.

1. Ferramentas nativas do Kotlin: Channel e Flow

Channel é um primitivo para transferência de dados entre coroutines, operando no princípio "produtor-consumidor". É ideal para criar uma fila de tarefas simples.

import kotlinx.coroutines.*import kotlinx.coroutines.channels.*

suspend fun main() = coroutineScope {    val channel = Channel<String>(capacity = 10) // canal bufferizado

    // Produtor (enfileirador de tarefas)    launch {        for (i in 1..5) {            val task = "Tarefa nº$i"            println("Enfileirada: $task")            channel.send(task)            delay(100)        }        channel.close() // fecha o canal após enviar todas as tarefas    }

    // Consumidor (processador)    launch {        for (task in channel) { // recebe automaticamente enquanto o canal estiver aberto            println("Processando: $task")            delay(300) // simulação de trabalho        }        println("Todas as tarefas processadas")    }}

Flow é um fluxo de dados assíncrono frio que pode ser usado para criar uma fila com capacidade de cancelamento e transformação.

import kotlinx.coroutines.*import kotlinx.coroutines.flow.*

fun taskQueue(): Flow<String> = flow {    for (i in 1..5) {        emit("Tarefa nº$i")        delay(200)    }}

suspend fun main() = coroutineScope {    taskQueue()        .map { task ->            "Processada: $task"        }        .collect { result ->            println(result)        }}

2. Kotlinx-coroutines: Dispatchers e Job

A biblioteca kotlinx-coroutines (parte do pacote oficial do Kotlin) fornece dispatchers (Dispatchers.Default, Dispatchers.IO) para executar tarefas em um pool de threads. Com Job e SupervisorJob, é possível gerenciar o ciclo de vida da fila.

import kotlinx.coroutines.*

suspend fun main() = coroutineScope {    val job = SupervisorJob()    val scope = CoroutineScope(Dispatchers.IO + job)

    // Adiciona tarefas à fila    scope.launch {        repeat(10) { i ->            delay(100)            println("Tarefa $i executando em ${Thread.currentThread().name}")        }    }

    // Aguarda a conclusão    delay(2000)    println("Thread principal continua trabalhando")}

Para cenários mais complexos (como tentativas repetidas, atrasos entre tarefas), pode-se usar kotlinx-coroutines-core com funções como retry ou withTimeout.

3. Biblioteca especializada: Kjob

Kjob é uma biblioteca leve para gerenciamento de tarefas em segundo plano em Kotlin, suportando filas, atrasos, tentativas repetidas e monitoramento. Ela funciona sobre coroutines e não requer dependências externas.

Instalação via Gradle:

implementation("io.github.oshai:kjob:2.2.0")

Exemplo de uso:

import io.