Delay vs Thread.sleep in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output difference between delay and Thread.sleep in coroutines

What will be the output of this Kotlin coroutine code snippet?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Start delay")
        delay(100)
        println("End delay")
    }
    launch {
        println("Start sleep")
        Thread.sleep(100)
        println("End sleep")
    }
}

A

Start delay
Start sleep
End sleep
End delay

B

Start delay
End delay
Start sleep
End sleep

C

Start sleep
End sleep
Start delay
End delay

D

Start sleep
Start delay
End delay
End sleep

💡 Hint

Remember that delay is a suspending function that doesn't block the thread, while Thread.sleep blocks the thread.

The delay call suspends the coroutine but allows other coroutines to run, so both "Start delay" and "Start sleep" print immediately. The Thread.sleep blocks the thread, so "End sleep" prints before "End delay".

🧠 Conceptual

intermediate

Why prefer delay over Thread.sleep in Kotlin coroutines?

Which reason best explains why delay is preferred over Thread.sleep in Kotlin coroutines?

A delay blocks the thread, making code simpler

B Thread.sleep is faster than delay

C delay suspends the coroutine without blocking the thread, allowing concurrency

D Thread.sleep automatically cancels coroutines

💡 Hint

Think about how blocking affects other coroutines running on the same thread.

delay suspends the coroutine but frees the thread to run other coroutines, improving concurrency. Thread.sleep blocks the thread, stopping all coroutines on it.

❓ Predict Output

advanced

Effect of Thread.sleep inside coroutine dispatcher

What will happen when running this Kotlin code?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        println("Before sleep")
        Thread.sleep(500)
        println("After sleep")
    }
    launch(Dispatchers.Default) {
        repeat(3) {
            println("Working $it")
            delay(200)
        }
    }
}

A

Before sleep
After sleep
Working 0
Working 1

B

Before sleep
After sleep
Working 0
Working 1
Working 2

C

Before sleep
Working 0
After sleep
Working 1
Working 2

D

Before sleep
Working 0
Working 1
Working 2
After sleep

💡 Hint

Consider how Thread.sleep blocks the thread and how many threads the Default dispatcher uses.

Thread.sleep blocks one thread in the Default dispatcher, but other threads run the second coroutine printing "Working" messages concurrently.

❓ Predict Output

advanced

Output of nested delay and Thread.sleep calls

What is the output of this Kotlin coroutine code?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Start outer")
        delay(100)
        launch {
            println("Start inner")
            Thread.sleep(100)
            println("End inner")
        }
        println("End outer")
    }
}

A

Start outer
End outer
Start inner
End inner

B

Start outer
Start inner
End inner
End outer

C

Start outer
Start inner
End outer
End inner

D

Start outer
End outer
End inner
Start inner

💡 Hint

Remember that launch starts a new coroutine immediately but does not block the parent coroutine.

The outer coroutine prints "Start outer", then delays. After delay, it launches the inner coroutine and immediately prints "End outer". The inner coroutine runs separately, printing "Start inner" and "End inner" after sleeping.

🧠 Conceptual

expert

Why does Thread.sleep cause coroutine starvation in single-threaded dispatcher?

In Kotlin coroutines, why can using Thread.sleep inside a coroutine running on Dispatchers.Unconfined or a single-threaded dispatcher cause starvation of other coroutines?

A Because Thread.sleep suspends only the current coroutine, allowing others to run

B Because Thread.sleep blocks the thread, preventing other coroutines from running on that thread

C Because Dispatchers.Unconfined creates multiple threads that compete for CPU

D Because delay internally uses Thread.sleep, causing blocking

💡 Hint

Think about what happens when the only thread available is blocked.

Thread.sleep blocks the thread it runs on. If the dispatcher uses a single thread, blocking it stops all coroutines scheduled on that thread, causing starvation. delay suspends without blocking, avoiding this problem.