Coroutines vs threads mental model in Kotlin - Hands-On Comparison

Coroutines vs Threads Mental Model in Kotlin

📖 Scenario: Imagine you are organizing a small bakery. You have two ways to handle orders: either hire many bakers (threads) who each work independently, or have a few bakers who can quickly switch tasks without waiting (coroutines).

🎯 Goal: You will create a simple Kotlin program to understand how coroutines differ from threads by simulating tasks that print messages with delays. This will help you see how coroutines are lightweight and efficient compared to threads.

📋 What You'll Learn

Create a thread that prints a message after a delay

Create a coroutine that prints a message after a delay

Use a configuration variable to set the delay time

Print the outputs to compare thread and coroutine behavior

💡 Why This Matters

🌍 Real World

Coroutines help apps stay responsive by doing many tasks without blocking the main work, like handling multiple bakery orders smoothly.

💼 Career

Understanding coroutines vs threads is key for Kotlin developers building efficient, fast, and responsive applications.

1

Create a thread that prints a message after a delay

Create a Thread named threadExample that waits for 1000 milliseconds and then prints "Thread: Baking bread". Start the thread.

Kotlin

# Create a Thread named threadExample that waits 1000ms and prints "Thread: Baking bread"
# Your code here

Need a hint?

Use Thread { ... } to create a thread and Thread.sleep(1000) to wait 1 second.

2

Add a delay configuration variable

Create an Int variable called delayTime and set it to 1000. Use this variable in the Thread.sleep() call inside threadExample.

Kotlin

val delayTime = 1000

val threadExample = Thread {
    Thread.sleep(delayTime)
    println("Thread: Baking bread")
}
threadExample.start()
# Your code here

Need a hint?

Define delayTime before the thread and replace the fixed 1000 with delayTime.

3

Create a coroutine that prints a message after a delay

Import kotlinx.coroutines.*. Create a runBlocking block. Inside it, launch a coroutine named coroutineExample that delays for delayTime milliseconds and then prints "Coroutine: Baking bread".

Kotlin

import kotlinx.coroutines.*

val delayTime = 1000

val threadExample = Thread {
    Thread.sleep(delayTime)
    println("Thread: Baking bread")
}
threadExample.start()

runBlocking {
    launch {
        delay(delayTime)
        println("Coroutine: Baking bread")
    }
}
# Your code here

Need a hint?

Use runBlocking to start coroutines in main, then launch to create a coroutine.

4

Print the final output to compare thread and coroutine

Add a println statement after starting the thread and launching the coroutine that prints "Main: Bakery is open". This shows the main program continues without waiting.

Kotlin

import kotlinx.coroutines.*

val delayTime = 1000

val threadExample = Thread {
    Thread.sleep(delayTime)
    println("Thread: Baking bread")
}
threadExample.start()

println("Main: Bakery is open")

runBlocking {
    launch {
        delay(delayTime)
        println("Coroutine: Baking bread")
    }
}
# Your code here

Need a hint?

Print "Main: Bakery is open" right after starting the thread to see the main thread is not blocked.