Coroutines vs threads mental model in Kotlin - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of coroutine vs thread switching

What is the output of this Kotlin code that uses a coroutine and a thread?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Start coroutine")
        delay(100)
        println("End coroutine")
    }
    Thread {
        println("Start thread")
        Thread.sleep(50)
        println("End thread")
    }.start()
    delay(200)
}

A

Start coroutine
Start thread
End thread
End coroutine

B

Start thread
Start coroutine
End coroutine
End thread

C

Start coroutine
End coroutine
Start thread
End thread

D

Start thread
End thread
Start coroutine
End coroutine

💡 Hint

Remember coroutines are lightweight and can suspend without blocking threads.

The coroutine starts and prints immediately, then suspends for 100ms. The thread starts and prints immediately, then sleeps for 50ms. So the thread finishes before the coroutine resumes.

🧠 Conceptual

intermediate

Difference in resource usage between coroutines and threads

Which statement best describes the difference in resource usage between Kotlin coroutines and threads?

A Coroutines use less memory and are more lightweight than threads because they share threads and suspend without blocking.

B Threads use less memory than coroutines because threads are managed by the OS.

C Coroutines and threads use the same amount of memory because both run concurrently.

D Threads are more lightweight because they can suspend without blocking, unlike coroutines.

💡 Hint

Think about how coroutines suspend without blocking threads.

Coroutines are lightweight because they do not require a dedicated thread and can suspend execution without blocking the underlying thread, saving memory and resources.

🔧 Debug

advanced

Identify the error in coroutine and thread usage

What error will this Kotlin code produce?

Kotlin

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        println("Coroutine running")
        delay(100)
        println("Coroutine finished")
    }
    Thread.sleep(50)
    println("Main finished")
}

A The program throws a runtime exception because delay cannot be called outside runBlocking.

B The program prints "Coroutine running" then "Main finished" and exits before "Coroutine finished" prints.

C The program prints all three lines in order without error.

D The program deadlocks and never finishes.

💡 Hint

Consider the lifecycle of GlobalScope coroutines and main thread.

The main thread sleeps 50ms and then prints "Main finished" and exits. The coroutine is launched but may not complete before the program ends, so "Coroutine finished" may never print.

❓ Predict Output

advanced

Output order with multiple coroutines and threads

What is the output of this Kotlin program?

Kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        println("Coroutine 1 start")
        delay(100)
        println("Coroutine 1 end")
    }
    launch {
        println("Coroutine 2 start")
        delay(50)
        println("Coroutine 2 end")
    }
    Thread {
        println("Thread start")
        Thread.sleep(75)
        println("Thread end")
    }.start()
}

A

Thread start
Coroutine 1 start
Coroutine 2 start
Thread end
Coroutine 2 end
Coroutine 1 end

B

Coroutine 2 start
Coroutine 1 start
Thread start
Coroutine 2 end
Coroutine 1 end
Thread end

C

Coroutine 1 start
Thread start
Coroutine 2 start
Coroutine 2 end
Thread end
Coroutine 1 end

D

Coroutine 1 start
Coroutine 2 start
Thread start
Coroutine 2 end
Thread end
Coroutine 1 end

💡 Hint

Coroutines start immediately but suspend at delay; thread runs independently with sleep.

Both coroutines print start immediately. Coroutine 2 delays 50ms and ends first. Thread sleeps 75ms and ends after coroutine 2. Coroutine 1 delays 100ms and ends last.

🧠 Conceptual

expert

Why coroutines are preferred over threads for concurrency in Kotlin

Which reason best explains why Kotlin coroutines are often preferred over threads for concurrency?

A Coroutines require more memory but provide better debugging tools than threads.

B Threads are faster than coroutines because they run on multiple CPU cores automatically.

C Coroutines allow writing asynchronous code sequentially and use fewer resources by suspending without blocking threads.

D Threads are easier to cancel and manage than coroutines in Kotlin.

💡 Hint

Think about how coroutines simplify asynchronous programming and resource use.

Coroutines let you write code that looks like normal sequential code but runs asynchronously. They suspend without blocking threads, so they use less memory and are easier to manage than threads.

Practice

1. Which statement best describes the difference between Kotlin coroutines and threads?

easy

A. Both coroutines and threads are managed by the OS and have the same weight.

B. Threads are lightweight and managed by Kotlin, coroutines are heavier and managed by the OS.

C. Coroutines are lightweight and managed by Kotlin, threads are heavier and managed by the OS.

D. Coroutines and threads are the same and can be used interchangeably without difference.

Solution

1. Step 1: Understand management of coroutines and threads

   Coroutines are managed by Kotlin's runtime, making them lightweight tasks.

2. Step 2: Understand thread management

   Threads are managed by the operating system and are heavier compared to coroutines.

3. Final Answer:

   Coroutines are lightweight and managed by Kotlin, threads are heavier and managed by the OS. -> Option C

4. Quick Check:

   Coroutines lightweight, threads OS-managed = A [OK]

Hint: Coroutines are Kotlin tasks; threads are OS tasks [OK]

Common Mistakes:

• Confusing which manages coroutines vs threads
• Thinking coroutines are OS threads
• Assuming threads are lightweight like coroutines

2. Which Kotlin code snippet correctly launches a coroutine?

easy

A. coroutineStart { println("Start") }

B. Thread { println("Hello from thread") }.start()

C. runBlocking { Thread.sleep(1000) }

D. launch { println("Hello from coroutine") }

Solution

1. Step 1: Identify coroutine launch syntax

   The correct way to start a coroutine in Kotlin is using the 'launch' builder inside a coroutine scope.

2. Step 2: Check other options for correctness

   Thread { println("Hello from thread") }.start() starts a thread, not a coroutine. runBlocking { Thread.sleep(1000) } uses runBlocking with Thread.sleep, which blocks a thread. coroutineStart { println("Start") } is invalid syntax.

3. Final Answer:

   launch { println("Hello from coroutine") } -> Option D

4. Quick Check:

   launch starts coroutine = A [OK]

Hint: Use 'launch' to start coroutines, not Thread or unknown keywords [OK]

Common Mistakes:

• Using Thread instead of launch for coroutines
• Confusing runBlocking with coroutine launch
• Using invalid coroutine syntax

3. What will be the output of this Kotlin code snippet?

import kotlinx.coroutines.*
fun main() = runBlocking {
  launch {
    delay(100)
    println("Coroutine finished")
  }
  println("Main finished")
}

medium

A. Main finished
Coroutine finished

B. Coroutine finished
Main finished

C. Main finished

D. Coroutine finished

Solution

1. Step 1: Understand runBlocking and launch behavior

   runBlocking blocks the main thread until its coroutine completes. The launch coroutine delays 100ms before printing.

2. Step 2: Trace output order

   "Main finished" prints immediately. After 100ms delay, "Coroutine finished" prints. runBlocking waits for launch to complete before exiting.

3. Final Answer:

   Main finished Coroutine finished -> Option A

4. Quick Check:

   runBlocking waits, delay delays launch = C [OK]

Hint: runBlocking waits; launch delays print [OK]

Common Mistakes:

• Assuming launch runs before main print
• Ignoring delay effect
• Thinking runBlocking doesn't wait

4. Identify the error in this Kotlin coroutine code:

fun main() {
  launch {
    println("Hello")
  }
}

medium

A. Missing coroutine scope to launch coroutine

B. Incorrect use of println inside coroutine

C. launch should be replaced with Thread

D. No error, code runs fine

Solution

1. Step 1: Check coroutine launch context

   launch must be called inside a coroutine scope or suspend function. Here, main is a regular function without scope.

2. Step 2: Identify missing coroutine scope

   Without a scope like runBlocking or CoroutineScope, launch cannot start a coroutine.

3. Final Answer:

   Missing coroutine scope to launch coroutine -> Option A

4. Quick Check:

   launch needs coroutine scope = B [OK]

Hint: launch needs coroutine scope like runBlocking [OK]

Common Mistakes:

• Trying to launch coroutine outside scope
• Replacing launch with Thread incorrectly
• Thinking println causes error

5. You want to perform multiple network calls concurrently without blocking the main thread. Which approach best uses Kotlin coroutines to achieve this?

hard

A. Create multiple threads and use Thread.sleep to wait for results

B. Launch multiple coroutines with async and await their results

C. Use a single coroutine and call blocking network functions sequentially

D. Run network calls on the main thread directly

Solution

1. Step 1: Understand concurrency with coroutines

   Using async inside coroutines allows concurrent execution and returns Deferred results.

2. Step 2: Compare options for efficiency and correctness

   Create multiple threads and use Thread.sleep to wait for results uses threads and blocking sleep, which is heavy and inefficient. Use a single coroutine and call blocking network functions sequentially blocks sequentially, losing concurrency. Run network calls on the main thread directly blocks main thread, causing UI freeze.

3. Final Answer:

   Launch multiple coroutines with async and await their results -> Option B

4. Quick Check:

   async + await = concurrent coroutines [OK]

Hint: Use async/await for concurrent coroutines, not threads [OK]

Common Mistakes:

• Using threads with sleep instead of coroutines
• Blocking main thread with network calls
• Running network calls sequentially inside one coroutine