Delay vs Thread.sleep in Kotlin - Hands-On Comparison

Delay vs Thread.sleep in Kotlin

📖 Scenario: You are building a simple Kotlin program to understand how to pause execution in two different ways: using Thread.sleep and delay from coroutines. This helps you see how blocking and non-blocking pauses work in real programs.

🎯 Goal: Create a Kotlin program that first pauses using Thread.sleep and then pauses using delay inside a coroutine. You will see the difference in how the program behaves.

📋 What You'll Learn

Create a main function

Use Thread.sleep to pause for 1000 milliseconds

Use delay to pause for 1000 milliseconds inside a coroutine

Print messages before and after each pause to observe the flow

💡 Why This Matters

🌍 Real World

Understanding blocking vs non-blocking pauses is important when writing apps that need to stay responsive, like games or user interfaces.

💼 Career

Many Kotlin jobs require knowledge of coroutines and how to manage delays without freezing the app, improving user experience.

1

Create the main function and print start message

Write a main function and inside it print "Program started".

Kotlin

fun main() {
    // Your code here
}

Need a hint?

Use fun main() to create the main function and println to print the message.

2

Add Thread.sleep to pause for 1000 milliseconds

Inside the main function, after printing "Program started", add Thread.sleep(1000) to pause the program for 1000 milliseconds, then print "After Thread.sleep".

Kotlin

fun main() {
    println("Program started")
    // Your code here
}

Need a hint?

Use Thread.sleep(1000) to pause for 1 second, then print the message after it.

3

Add coroutine with delay to pause without blocking

Import kotlinx.coroutines.*. Inside main, add runBlocking block. Inside it, print "Before delay", then call delay(1000), then print "After delay".

Kotlin

import kotlinx.coroutines.*

fun main() {
    println("Program started")
    Thread.sleep(1000)
    println("After Thread.sleep")
    // Your code here
}

Need a hint?

Use runBlocking to start a coroutine in main. Inside it, use delay(1000) to pause without blocking the thread.

4

Print final message after coroutine block

After the runBlocking block in main, print "Program ended" to show the program finished.

Kotlin

import kotlinx.coroutines.*

fun main() {
    println("Program started")
    Thread.sleep(1000)
    println("After Thread.sleep")

    runBlocking {
        println("Before delay")
        delay(1000)
        println("After delay")
    }
    // Your code here
}

Need a hint?

Print "Program ended" after the coroutine finishes to see the full flow.