Coroutines vs threads mental model in Kotlin - Visual Side-by-Side Comparison

Concept Flow - Coroutines vs threads mental model

Start Main Thread

↓

Launch Coroutine

↓

Coroutine Suspends?

Yes→Save State, Free Thread

↓

Thread Executes Other Tasks

↓

Coroutine Runs

↓

Coroutine Completes

↓

Main Thread Continues

Shows how coroutines run on threads, can suspend without blocking, freeing threads to do other work, unlike threads which block while running.

Execution Sample

Kotlin

import kotlinx.coroutines.*

fun main() {
  println("Start")
  GlobalScope.launch {
    delay(1000)
    println("Coroutine done")
  }
  println("End")
  Thread.sleep(2000) // Keep JVM alive to see coroutine output
}

Starts main thread, launches coroutine that delays without blocking, main thread prints 'End' immediately.

Execution Table

Step	Action	Thread State	Coroutine State	Output
1	Start main function	Main thread running	No coroutine yet	Start
2	Launch coroutine	Main thread running	Coroutine started, running	Start
3	Print 'End'	Main thread running	Coroutine running (delay started)	Start End
4	Coroutine delays (suspends)	Main thread free for other tasks	Coroutine suspended, state saved	Start End
5	After 1 second, coroutine resumes	Main thread running coroutine	Coroutine resumed	Start End
6	Coroutine prints 'Coroutine done'	Main thread running coroutine	Coroutine completes	Start End Coroutine done
7	Main function ends	Main thread ends	Coroutine ended	Start End Coroutine done

💡 Coroutine completes after delay, main thread is never blocked during coroutine suspension.

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
Main thread	Running main	Running main + launching coroutine	Running main (prints End)	Running coroutine	Ended
Coroutine	Not started	Started and running	Suspended (delay)	Resumed and running	Completed

Key Moments - 3 Insights

Why does the main thread print 'End' before 'Coroutine done'?

Because the coroutine suspends during delay (see step 4 in execution_table), freeing the main thread to continue and print 'End' immediately.

Does launching a coroutine create a new thread?

No, launching a coroutine does not create a new thread; it runs on existing threads and suspends without blocking them (see thread state in steps 2-4).

What happens to the thread when the coroutine suspends?

The thread is freed to do other work while the coroutine's state is saved (step 4), unlike a thread which would block and wait.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the state of the coroutine?

A Running without interruption

B Suspended with state saved

C Completed

D Not started yet

💡 Hint

Check the 'Coroutine State' column at step 4 in the execution_table.

At which step does the main thread print 'End'?

A Step 1

B Step 2

C Step 3

D Step 6

💡 Hint

Look at the 'Output' column and find when 'End' appears.

If the coroutine did not suspend during delay, what would happen to the main thread?

A Main thread would block and wait

B Main thread would create a new thread

C Main thread would continue immediately

D Main thread would end before coroutine starts

💡 Hint

Refer to the 'Thread State' column in steps 3 and 4 to understand thread behavior during suspension.

Concept Snapshot

Coroutines run on threads but can suspend without blocking them.
Threads block when running tasks; coroutines free threads during suspension.
Launching a coroutine does not create a new thread.
Coroutines save state on suspension and resume later.
This allows efficient multitasking without many threads.

Full Transcript

This visual trace shows how Kotlin coroutines differ from threads. The main thread starts and launches a coroutine. The coroutine begins running but suspends during a delay, freeing the main thread to continue and print 'End' immediately. Later, the coroutine resumes and prints 'Coroutine done'. Unlike threads, coroutines do not block threads when suspended, enabling efficient multitasking. The variable tracker shows main thread and coroutine states changing step by step. Key moments clarify common confusions about suspension and thread usage. The quiz tests understanding of coroutine states and thread behavior during execution.