Trabalhando com filas de tarefas em Kotlin: na prática

Introdução: por que filas de tarefas são necessárias em Kotlin?

Aplicativos modernos cada vez mais exigem processamento paralelo de dados, operações em segundo plano e chamadas assíncronas. Sem um gerenciamento adequado de tarefas, seu código pode enfrentar problemas de desempenho, vazamentos de memória ou "congelamentos" da interface. As filas de tarefas em Kotlin não são apenas uma abstração, mas uma ferramenta poderosa que ajuda a organizar a execução do trabalho na ordem correta, com controle do número de threads e prioridades.

Neste artigo, vamos explorar abordagens práticas para implementar filas de tarefas em Kotlin: desde o clássico ThreadPoolExecutor até coroutines com seus dispatchers flexíveis. Você verá como aplicar essas técnicas em projetos reais e obterá exemplos de código prontos.

1. Abordagem clássica: ThreadPoolExecutor e BlockingQueue

A biblioteca padrão do Java (e Kotlin, como linguagem JVM) fornece a poderosa classe ThreadPoolExecutor. Ela gerencia um pool de threads e usa uma fila bloqueante interna para armazenar tarefas pendentes.

Criando uma fila com número fixo de threads

O caso mais simples é um pool com um número fixo de threads. Todas as tarefas que não podem ser executadas imediatamente são colocadas na fila LinkedBlockingQueue.

import java.util.concurrent.Executors\nimport java.util.concurrent.TimeUnit\n\nfun main() {\n    val executor = Executors.newFixedThreadPool(3)\n\n    for (i in 1..10) {\n        executor.submit {\n            println("Tarefa $i executando na thread ${Thread.currentThread().name}")\n            Thread.sleep(1000)\n        }\n    }\n\n    executor.shutdown()\n    executor.awaitTermination(1, TimeUnit.MINUTES)\n    println("Todas as tarefas concluídas")\n}\n

Este código demonstra uma fila básica: as tarefas são enviadas ao pool e, se todas as threads estiverem ocupadas, elas aguardam na fila.

Fila prioritária: PriorityBlockingQueue

Às vezes, é necessário executar tarefas urgentes antes das outras. Para isso, usamos PriorityBlockingQueue com um comparador personalizado.

import java.util.concurrent.PriorityBlockingQueue\nimport java.util.concurrent.ThreadPoolExecutor\nimport java.util.concurrent.TimeUnit\n\ndata class PriorityTask(val priority: Int, val name: String) : Comparable<PriorityTask> {\n    override fun compareTo(other: PriorityTask): Int = other.priority - this.priority\n}\n\nfun main() {\n    val queue = PriorityBlockingQueue<Runnable>(10) { r1, r2 ->\n        val t1 = (r1 as PriorityTaskWrapper).task\n        val t2 = (r2 as PriorityTaskWrapper).task\n        t1.compareTo(t2)\n    }\n\n    val executor = ThreadPoolExecutor(2, 4, 1, TimeUnit.SECONDS, queue)\n\n    class PriorityTaskWrapper(val task: PriorityTask, val action: () -> Unit) : Runnable {\n        override fun run() = action()\n    }\n\n    for (i in 1..5) {\n        val priority = if (i % 2 == 0) 10 else 1\n        executor.submit(PriorityTaskWrapper(PriorityTask(priority, "Tarefa $i")) {\n            println("Executando: ${PriorityTask(priority, "Tarefa $i")}")\n            Thread.sleep(500)\n        })\n    }\n\n    executor.shutdown()\n    executor.awaitTermination(1, TimeUnit.MINUTES)\n}\n

Aqui, as tarefas com priority = 10 serão executadas antes das com priority = 1, mesmo se forem adicionadas depois.

2. Filas de tarefas com coroutines (kotlinx.coroutines)

O Kotlin moderno oferece coroutines — threads leves que permitem construir filas assíncronas sem gerenciamento direto de threads. As principais ferramentas são Channel e Dispatchers.

Fila simples via Channel

Channel é um análogo de uma fila bloqueante, mas para coroutines. Ele permite transferir tarefas com segurança entre coroutines.

import kotlinx.coroutines.*\nimport kotlinx.coroutines.channels.Channel\n\nsuspend fun processTas