Agendador de Tarefas Kotlin: kotlinx.coroutines e bibliotecas para tarefas em segundo plano

Agendador de tarefas em Kotlin: de corrotinas a soluções corporativas

Kotlin é uma linguagem de programação moderna, ativamente usada para criar aplicações servidoras, móveis e de desktop. Uma das necessidades-chave em tais projetos é a execução de tarefas agendadas ou em segundo plano. Neste artigo, vamos analisar quais ferramentas e bibliotecas Kotlin permitem organizar um agendador de tarefas e fornecer exemplos práticos de código.

Vamos considerar três abordagens principais:

• Ferramentas integradas do Kotlin Coroutines (threads leves)
• Biblioteca WorkManager para Android
• Clássico Quartz Scheduler com wrappers Kotlin

1. Agendador baseado em kotlinx.coroutines

kotlinx.coroutines é a biblioteca padrão para programação assíncrona em Kotlin. Ela fornece ferramentas poderosas para criar tarefas atrasadas e periódicas.

Componentes principais:

• delay() — atraso na execução da corrotina
• launch e async — inicialização de corrotinas
• CoroutineScope — gerenciamento do ciclo de vida
• Dispatchers — escolha da thread de execução

Exemplo de um agendador de tarefas simples com repetição a cada 5 segundos:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(10) { i ->            println("Tarefa #$i executada em ${System.currentTimeMillis()}")            delay(5000) // pausa de 5 segundos        }    }    job.join()    println("Agendador concluiu o trabalho")}

Para cenários mais complexos (cancelamento de tarefas, tratamento de erros, limitação de frequência), use Job e SupervisorJob:

val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())

fun schedulePeriodicTask(intervalMs: Long, action: suspend () -> Unit): Job {    return scope.launch {        while (isActive) {            try {                action()            } catch (e: Exception) {                println("Erro: ${e.message}")            }            delay(intervalMs)        }    }}

// Usoval task = schedulePeriodicTask(2000) {    println("Tarefa em segundo plano em execução...")}

// Cancelamento após 10 segundosscope.launch {    delay(10000)    task.cancel()    println("Tarefa cancelada")}

Prós: leveza, suporte integrado a cancelamento, integração com o ecossistema Kotlin. Contras: não adequado para aplicações Android que precisam sobreviver a reinicializações do sistema.

2. WorkManager para Android (Kotlin)

WorkManager é uma biblioteca do Google para executar tarefas atrasadas e em segundo plano no Android, mesmo após o fechamento do aplicativo ou reinicialização do dispositivo. Funciona sobre corrotinas.

Passos principais:

1. Criar uma classe que herda de CoroutineWorker
2. Implementar o método doWork()
3. Configurar uma WorkRequest (única ou periódica)
4. Colocar a tarefa na fila através do WorkManager

Exemplo de tarefa periódica:

class MyPeriodicWorker(context: Context, params: WorkerParameters) :     CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {        return try {            // Sua tarefa: sincronização, limpeza, etc.            println("Tarefa periódica executada em ${System.currentTimeMillis()}")            Result.success()        } catch (e: Exception) {            Result.retry()        }    }}

// Configuração e inicializaçãoval constraints = Constraints.Builder()    .setRequiredNetworkType(NetworkType.CONNECTED)    .build()

val periodicRequest = PeriodicWorkRequestBuilder&