Planejador de Tarefas Kotlin: visão geral e exemplos |…

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

O planejador de tarefas é um componente importante de qualquer aplicação, permitindo executar código em horários agendados, com atraso ou periodicamente. Na linguagem Kotlin, especialmente no desenvolvimento em JVM, Android ou projetos multiplataforma, existem várias maneiras de implementar planejadores. Neste artigo, veremos detalhadamente as principais ferramentas: recursos integrados do kotlinx-coroutines-core, java.util.Timer, java.util.concurrent.Executors, bem como a biblioteca especializada korGE para jogos e animações.

1. Planejador de tarefas baseado em corrotinas (kotlinx-coroutines-core)

Esta é a maneira mais moderna e recomendada para aplicações Kotlin. A biblioteca kotlinx-coroutines-core fornece meios flexíveis para execução atrasada e periódica de código.

Instalação

Adicione a dependência no build.gradle.kts:

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

Tarefa atrasada (delay)

Atraso simples de execução usando delay dentro de uma corrotina:

import kotlinx.coroutines.*

fun main() = runBlocking {    println("Início: ${System.currentTimeMillis()}")    delay(2000) // atraso de 2 segundos    println("Executado após 2 segundos: ${System.currentTimeMillis()}")}

Tarefa periódica com launch e while

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch {        repeat(5) { i ->            println("Tarefa #${i + 1}: ${System.currentTimeMillis()}")            delay(1000)        }    }    job.join()}

Uso de Dispatchers para threads em segundo plano

O planejador pode operar em diferentes dispatchers, como Dispatchers.IO para operações de rede:

import kotlinx.coroutines.*

fun main() = runBlocking {    val job = launch(Dispatchers.IO) {        println("Executando na thread: ${Thread.currentThread().name}")        delay(3000)        println("Concluído")    }    job.join()}

2. Planejador clássico: java.util.Timer

Se você está trabalhando em um ambiente JVM e deseja usar a abordagem tradicional, Timer e TimerTask são adequados para cenários simples.

import java.util.*

fun main() {    val timer = Timer()    val task = object : TimerTask() {        override fun run() {            println("Tarefa periódica: ${System.currentTimeMillis()}")        }    }    // Inicia a tarefa após 1 segundo, depois a cada 2 segundos    timer.schedule(task, 1000, 2000)

    // Para após 10 segundos    Thread.sleep(10000)    timer.cancel()}

Tarefa única com atraso

val timer = Timer()timer.schedule(object : TimerTask() {    override fun run() {        println("Tarefa única após 3 segundos")    }}, 3000)

3. Planejador com Executors (ScheduledExecutorService)

Uma ferramenta mais poderosa e flexível do Java Concurrency, que se integra bem com Kotlin.

import java.util.concurrent.*

fun main() {    val scheduler = Executors.newScheduledThreadPool(2)

    // Tarefa com atraso    scheduler.schedule({        println("Tarefa atrasada: ${System.currentTimeMillis()}")    }, 2, TimeUnit.SECONDS)

    // Tarefa periódica com atraso fixo    val periodicTask = scheduler.scheduleWithFixedDelay({        println("Tarefa periódica: ${System.currentTimeMillis()}")    }, 1, 3, TimeUnit.SECONDS)

    // Para após 15 segundos    Thread.sleep(15000)    periodicTask.cancel(false)    scheduler.shutdown()}