Delay vs Thread.sleep in Kotlin - Visual Side-by-Side Comparison

Concept Flow - Delay vs Thread.sleep

Start Coroutine

↓

Call delay(1000)

↓

Coroutine Suspends

↓

Other coroutines run

↓

After 1 second

↓

Coroutine Resumes

↓

Continue execution

↓

Start Thread

↓

Call Thread.sleep(1000)

↓

Thread Blocks

↓

No other code runs in this thread

↓

After 1 second

↓

Thread wakes up

↓

Continue execution

Shows how delay suspends a coroutine allowing others to run, while Thread.sleep blocks the thread stopping all work on it.

Execution Sample

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
  println("Start")
  delay(1000)
  println("End")
}

This code prints Start, waits 1 second without blocking, then prints End.

Execution Table

Step	Action	State	Output
1	Start runBlocking coroutine	Coroutine active	Prints 'Start'
2	Call delay(1000)	Coroutine suspends, thread free	No output
3	Other coroutines or main thread can run	Coroutine suspended	No output
4	After 1 second delay ends	Coroutine resumes	No output
5	Print 'End'	Coroutine active	Prints 'End'
6	Coroutine completes	Coroutine finished	No output

💡 Coroutine finishes after printing 'End'

Variable Tracker

Variable	Start	After delay	After resume	Final
Coroutine State	Active	Suspended	Active	Finished

Key Moments - 3 Insights

Why does delay not block the whole program?

Because delay suspends only the coroutine, freeing the thread to run other coroutines or tasks, as shown in execution_table step 3.

What happens to the thread during Thread.sleep?

The thread is blocked and cannot do any other work until sleep finishes, unlike delay which suspends coroutine but keeps thread free.

Can delay be used outside coroutines?

No, delay is a suspend function and must be called inside a coroutine or another suspend function.

Visual Quiz - 3 Questions

Look at the execution table, what is the coroutine state right after calling delay(1000)?

A Active

B Suspended

C Finished

D Blocked

💡 Hint

Check execution_table row 2 under 'State' column

At which step does the coroutine resume after delay?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look for 'Coroutine resumes' in execution_table

If Thread.sleep was used instead of delay, what would happen to the thread?

A Thread would block and no other code runs on it

B Thread would suspend but allow other coroutines

C Thread would continue running other coroutines

D Thread would crash

💡 Hint

Refer to concept_flow section about Thread.sleep behavior

Concept Snapshot

delay(1000) suspends coroutine without blocking thread
Thread.sleep(1000) blocks the thread completely
Use delay inside coroutines for non-blocking waits
Thread.sleep blocks all work on the thread
delay allows other coroutines to run during wait

Full Transcript

This visual execution compares delay and Thread.sleep in Kotlin. delay suspends a coroutine, freeing the thread to run other coroutines, shown by the coroutine state changing to suspended and resuming after 1 second. Thread.sleep blocks the entire thread, stopping all work on it until the sleep ends. The example code runs a coroutine that prints 'Start', delays 1 second without blocking, then prints 'End'. Key points: delay is non-blocking and must be used inside coroutines; Thread.sleep blocks the thread and should be avoided in coroutines.