Planejador de Tarefas Kotlin: visão geral e exemplos de uso

Planejador de Tarefas em Kotlin: guia completo

O planejador de tarefas (Task Scheduler) é uma ferramenta poderosa que permite automatizar a execução de determinadas ações em um horário específico ou com uma periodicidade definida. Na linguagem Kotlin, que é amplamente utilizada para desenvolvimento de aplicações servidoras, aplicativos Android e até scripts, existem várias maneiras de implementar um planejador de tarefas. Neste artigo, abordaremos detalhadamente as principais abordagens, suas vantagens e forneceremos exemplos práticos de código.

Para que serve um planejador de tarefas?

O planejador de tarefas resolve diversos problemas comuns no desenvolvimento:

• Envio automático de notificações (email, push notifications) agendadas.
• Limpeza de dados temporários (cache, sessões de usuários) uma vez por dia.
• Sincronização periódica com APIs externas ou bancos de dados.
• Execução de tarefas em segundo plano em aplicativos Android (WorkManager).
• Agendamento de backups e relatórios.

Principais formas de implementar um planejador em Kotlin

Vamos considerar as três abordagens mais populares: uso de corrotinas, o clássico Timer e o ScheduledExecutorService do Java. Cada uma delas tem suas particularidades.

1. Planejador baseado em corrotinas Kotlin

Corrotinas são uma forma moderna e eficiente de trabalhar com assincronicidade em Kotlin. Para criar um planejador, basta usar a função delay() dentro de uma corrotina. Essa abordagem é leve, não bloqueia a thread e é ideal para tarefas simples.

import kotlinx.coroutines.*

fun main() = runBlocking {    println("Planejador iniciado. A tarefa será executada em 3 segundos.")

    // Agendamos uma tarefa com atraso    val job = launch {        delay(3000L) // 3 segundos        println("Tarefa executada: tempo esgotado!")    }

    // Aguardamos a conclusão da tarefa    job.join()    println("Programa finalizado.")}

Para tarefas repetitivas, use um loop dentro da corrotina:

import kotlinx.coroutines.*

fun main() = runBlocking {    println("A tarefa será executada a cada 2 segundos, 5 vezes.")

    val job = launch {        repeat(5) { iteration ->            delay(2000L)            println("Execução #${iteration + 1}: ${System.currentTimeMillis()}")        }    }

    job.join()    println("Todas as tarefas agendadas foram executadas.")}

2. Timer clássico (Java/Kotlin)

java.util.Timer é uma forma simples e familiar para muitos desenvolvedores. Ele permite agendar tarefas com atraso e periodicidade. No entanto, vale lembrar que o Timer usa uma única thread e, se uma tarefa demorar muito, pode atrasar as subsequentes.

import java.util.*

fun main() {    val timer = Timer()

    // Agendamos uma tarefa com atraso de 2 segundos    timer.schedule(object : TimerTask() {        override fun run() {            println("Tarefa executada após 2 segundos.")        }    }, 2000L)

    // Agendamos uma tarefa repetitiva a cada 1.5 segundos, começando após 1 segundo    timer.schedule(object : TimerTask() {        override fun run() {            println("Tarefa repetitiva: ${System.currentTimeMillis()}")        }    }, 1000L, 1500L)

    // Damos tempo para a execução das tarefas    Thread.sleep(5000L)    timer.cancel()    println("Timer parado.")}

3. ScheduledExecutorService (recomendado para ambientes multithread)

Esta classe do Java java.util.concurrent oferece recursos mais flexíveis: pool de threads, tratamento de exceções e cancelamento de tarefas. É preferível ao Timer em projetos sérios.

import java.util.concurrent.*

fun main() {    val scheduler = Executors.newScheduledThre