Планировщик задач Kotlin: руководство и примеры

Планировщик задач на Kotlin: полное руководство

Планировщик задач (Task Scheduler) — это мощный инструмент, позволяющий автоматизировать выполнение определённых действий в заданное время или с заданной периодичностью. В языке Kotlin, который активно используется для разработки серверных приложений, Android-приложений и даже скриптов, существует несколько способов реализации планировщика задач. В этой статье мы подробно рассмотрим основные подходы, их преимущества и приведём практические примеры кода.

Зачем нужен планировщик задач?

Планировщик задач решает множество типовых задач в разработке:

Автоматическая отправка уведомлений (email, push-уведомления) по расписанию.
Очистка временных данных (кэш, сессии пользователей) раз в сутки.
Периодическая синхронизация с внешними API или базами данных.
Выполнение фоновых задач в Android-приложениях (WorkManager).
Планирование резервного копирования и отчётов.

Основные способы реализации планировщика в Kotlin

Рассмотрим три наиболее популярных подхода: использование корутин, классического Timer и ScheduledExecutorService из Java. Каждый из них имеет свои особенности.

1. Планировщик на основе корутин Kotlin

Корутины — это современный и эффективный способ работы с асинхронностью в Kotlin. Для создания планировщика достаточно использовать функцию delay() внутри корутины. Этот подход лёгок, не блокирует поток и идеально подходит для простых задач.

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Планировщик запущен. Задача будет выполнена через 3 секунды.")

    // Планируем задачу с задержкой
    val job = launch {
        delay(3000L) // 3 секунды
        println("Задача выполнена: время истекло!")
    }

    // Ожидаем завершения задачи
    job.join()
    println("Программа завершена.")
}

Для повторяющихся задач используйте цикл внутри корутины:

import kotlinx.coroutines.*

fun main() = runBlocking {
    println("Задача будет выполняться каждые 2 секунды 5 раз.")

    val job = launch {
        repeat(5) { iteration ->
            delay(2000L)
            println("Выполнение #${iteration + 1}: ${System.currentTimeMillis()}")
        }
    }

    job.join()
    println("Все запланированные задачи выполнены.")
}

2. Классический Timer (Java/Kotlin)

java.util.Timer — простой и знакомый многим разработчикам способ. Он позволяет планировать задачи с задержкой и периодичностью. Однако стоит помнить, что Timer использует один поток, и если задача выполняется долго, это может задержать последующие.

import java.util.*

fun main() {
    val timer = Timer()

    // Планируем задачу с задержкой 2 секунды
    timer.schedule(object : TimerTask() {
        override fun run() {
            println("Задача выполнена через 2 секунды.")
        }
    }, 2000L)

    // Планируем повторяющуюся задачу каждые 1.5 секунды, начиная через 1 секунду
    timer.schedule(object : TimerTask() {
        override fun run() {
            println("Повторяющаяся задача: ${System.currentTimeMillis()}")
        }
    }, 1000L, 1500L)

    // Даём время на выполнение задач
    Thread.sleep(5000L)
    timer.cancel()
    println("Timer остановлен.")
}

3. ScheduledExecutorService (рекомендуемый для многопоточных сред)

Этот класс из Java java.util.concurrent предоставляет более гибкие возможности: пул потоков, обработку исключений и отмену задач. Он предпочтительнее Timer в серьёзных проектах.

import java.util.concurrent.*

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

    // Задача с задержкой 3 секунды
    val task1 = scheduler.schedule({
        println("Одноразовая задача выполнена через 3 сек.")
    }, 3, TimeUnit.SECONDS)

    // Периодическая задача с начальной задержкой 1 сек и интервалом 2 сек
    val task2 = scheduler.scheduleAtFixedRate({
        println("Периодическая задача: ${System.currentTimeMillis()}")
    }, 1, 2, TimeUnit.SECONDS)

    // Ожидаем и останавливаем
    Thread.sleep(7000L)
    task1.cancel(false)
    task2.cancel(false)
    scheduler.shutdown()
    println("Scheduler остановлен.")
}