Understanding Thread Switching and Task Flow in Kotlin Coroutines – Part 1

Introduction

When I kept seeing articles about Kotlin coroutines, I realized that most of them failed to solve readers' real problems. After reviewing popular coroutine articles, I confirmed this impression and decided to write a comprehensive guide because asynchronous programming is too important to ignore.

Existing resources suffer from several issues:

The official documentation focuses on usage and rarely explains the underlying principles, leading to many pitfalls for developers who do not grasp the fundamentals.

Many blog posts merely repeat the official docs with a few examples, offering little incremental information .

The quality of blog posts varies widely; some unverified concepts confuse readers instead of clarifying them.

Articles that dive into source code often lack a clear narrative, making the trace hard to follow and missing key concept introductions.

Why are coroutines so difficult to describe?

Structured concurrency (writing asynchronous code in a synchronous style) feels refreshing but is a radical shift from prior experience.

Coroutines introduce many new concepts such as CoroutineScope and CoroutineContext , increasing the learning curve.

They also bring "magic" like the suspend keyword, which adds compile‑time transformations that are crucial to understand.

The notion of coroutine resumption is core to why coroutines differ from simple thread pools, yet it is often glossed over.

Implementation details are often obscured , causing the main ideas to be hidden behind magic.

To address these difficulties, I will adopt the following methods:

Start from basic thread concepts, clarify common misconceptions that are essential for understanding coroutines, while avoiding unrelated details.

Proceed step‑by‑step , following the historical development of asynchronous programming as the main thread , and illustrate which problems coroutines solve.

Use simple simulation implementations (inspired by Feynman's "What I cannot create, I do not understand") to lower the steep learning curve .

Share my own unique insights and relate them to everyday scenarios for better intuition.

Provide hands‑on exercises so that knowledge is retained rather than forgotten.

Thread

What is thread switching? Why do we need to switch threads? How do we switch threads?

Let's start with a simple example that actually switches threads:

// Thread1.kt
fun main() {
    printlnWithThread("do work 1")
    switchThread()
    printlnWithThread("do work 3")
}

fun switchThread() = thread {
    printlnWithThread("do work 2")
}

fun printlnWithThread(message: String) {
    println("${Thread.currentThread().name}: $message")
}
// log output
// main: do work 1
// Thread-0: do work 2
// main: do work 3

The thread function is a Kotlin wrapper around new Thread().start() . The log shows that work 2 runs on a new thread, confirming a successful thread switch.

However, this naïve switch does not guarantee the expected order when work 2 is a time‑consuming task. To keep the sequence work1 → work2 → work3 without blocking the main thread, we need a non‑blocking approach.

One solution is to let the background thread notify the main thread after finishing its work, allowing the main thread to continue other tasks in the meantime. The following example demonstrates this idea:

// Thread3.kt
val work = Runnable {
    printlnWithThread("do work 1")
    switchThread3()
}

val otherWork1 = Runnable {
    Thread.sleep(100) // simulate other work
    printlnWithThread("do work a")
}

val otherWork2 = Runnable {
    printlnWithThread("do work X")
}

val works = ConcurrentLinkedQueue
()

fun main() {
    works.addAll(listOf(work, otherWork1, otherWork2))
    works.forEach { it.run() }
}

fun switchThread3() = thread {
    printlnWithThread("do work 2")
    works.add(Runnable { printlnWithThread("do work 3") })
}
// log output shows the intended order while keeping the main thread non‑blocked.

This pattern resembles Android's Handler and Looper mechanism, which is essentially an event loop that moves tasks between thread queues.

Understanding that a thread merely executes tasks from its queue helps clarify why we cannot literally "cut" a thread; instead we transfer tasks across threads.

Summary

A thread's current task determines its execution context; threads are relentless execution machines. We cannot "switch" a thread directly, but we can move tasks (via CoroutineDispatcher in Kotlin coroutines) between threads, achieving the desired effect of "thread switching" through task flow.

In the next article we will explore thread pools, which are a milestone for asynchronous frameworks and a key foundation for Kotlin coroutines.

Source code: https://github.com/chdhy/kotlin-coroutine-learn

Exercise: Implement the examples to experience the shift from "thread switching" to "task flow".

Like 👍 this article and follow ❤️ the author for more updates.