How to call a function after delay in Kotlin?

Introduction

In Kotlin, there are multiple approaches to implement delayed function calls. The most common method involves using coroutines with the delay function, enabling delayed execution without blocking threads.

1. Using Coroutines and delay Function

Kotlin coroutines provide a powerful concurrency solution that allows you to write asynchronous code in a synchronous manner. Using the delay function within coroutines facilitates non-blocking delays.

Here is a simple example demonstrating how to use coroutines and delay in Kotlin to delay function calls:

kotlin
import kotlinx.coroutines.*

fun main() = runBlocking { // This top-level coroutine starts the execution
    println("Execution started...")
    delayFunction()
    println("Continuing with other tasks")
}

suspend fun delayFunction() {
    delay(2000) // Delay for 2000 milliseconds (2 seconds)
    println("Delayed function call executed")
}

In the above code, we start a coroutine using runBlocking in the main function. We then call the delayFunction (a suspend function) with delay(2000) to introduce a 2-second delay. This delay does not block the execution of other tasks, so println("Continuing with other tasks") runs immediately after delayFunction.

2. Using Timer and TimerTask

If you prefer not to use coroutines, you can alternatively use Java's Timer and TimerTask. This is a conventional method suitable for straightforward delayed operations.

Here is an example demonstrating how to use Timer and TimerTask in Kotlin:

kotlin
import java.util.*

fun main() {
    val timer = Timer()
    timer.schedule(object : TimerTask() {
        override fun run() {
            println("Delayed function call executed")
        }
    }, 2000) // Delay for 2000 milliseconds (2 seconds)

    println("Continuing with other tasks")
}

In this example, we create a Timer object and schedule a task to run at a future time using the schedule method. This approach also does not block the main thread, allowing other tasks to execute.

Summary

Depending on your specific requirements (e.g., whether you're already using coroutines and your concurrency needs), you can choose between using coroutines with the delay function or the traditional Timer and TimerTask to implement delayed function calls. Generally, coroutines offer a more modern, robust, and manageable solution for handling concurrency and delayed tasks.