Coroutines vs threads mental model in Kotlin - Performance Comparison

Time Complexity: Coroutines vs threads mental model

O(n)

Understanding Time Complexity

When working with coroutines and threads in Kotlin, it is important to understand how their execution costs grow as we increase workload.

We want to see how the time taken changes when we run many tasks using coroutines versus threads.

Scenario Under Consideration

Analyze the time complexity of launching multiple tasks using threads and coroutines.

fun runThreads(n: Int) {
    repeat(n) {
        Thread {
            // some work
        }.start()
    }
}

suspend fun runCoroutines(n: Int) {
    repeat(n) {
        kotlinx.coroutines.GlobalScope.launch {
            // some work
        }
    }
}
    

This code runs n tasks either by creating n threads or launching n coroutines.

Identify Repeating Operations

Look at what repeats as input size grows.

• Primary operation: Creating and running n tasks (threads or coroutines).
• How many times: Exactly n times, once per task.

How Execution Grows With Input

As we increase n, the number of tasks grows linearly.

Input Size (n)	Approx. Operations
10	10 tasks created and run
100	100 tasks created and run
1000	1000 tasks created and run

Pattern observation: The work grows directly with the number of tasks.

Final Time Complexity

Time Complexity: O(n)

This means the time to start and run all tasks grows in a straight line as we add more tasks.

Common Mistake

[X] Wrong: "Coroutines always run faster than threads because they are lightweight."

[OK] Correct: While coroutines use fewer resources, the total time depends on the work done and how tasks are scheduled, not just on their lightweight nature.

Interview Connect

Understanding how coroutines and threads scale helps you explain efficient multitasking in Kotlin, a skill useful in many programming situations.

Self-Check

What if we changed the tasks to do heavy CPU work instead of light work? How would the time complexity change?

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