Kotlin Coroutines & Flow: Learn How They Really Work

Master Kotlin Coroutines and Flow through suspension, concurrency, cancellation, exceptions, and real execution models.

Created byDev Chan

Last updated 10/2026

English

What you'll learn

Understand how Kotlin coroutines work under the hood, including suspension, continuations, coroutine state machines, and how suspended code resumes execution.
Learn how to use coroutine builders effectively, including launch, async, coroutineScope, supervisorScope, and runBlocking.
Master structured concurrency and understand how parent-child relationships, coroutine lifecycles, completion, and failures are managed.
Understand coroutine cancellation from the inside out, including cancellation propagation, cooperative cancellation, CancellationException and finally
Develop a strong mental model for concurrent programming, allowing you to reason about coroutine behavior instead of simply memorizing APIs.
Debug and troubleshoot coroutine-based code with confidence by understanding what happens during suspension, resumption, cancellation, and failure.
Build knowledge that goes beyond Kotlin, including fundamental concepts such as suspension, continuations, asynchronous programming, cooperative cancellation

Course content

8 sections • 84 lectures • 9h 48m total length

From Threads to Coroutines: Understanding the Problem4:08
Understand why concurrency is needed and the problems that arise when relying on traditional threads.
Thread Crashes and Their Limits2:46
Explore the practical limitations of threads and why creating too many threads becomes a problem.
Coroutine Scalability: 100,000 Coroutines vs Threads5:47
See why coroutines are lightweight by comparing them with threads at large scale.
Introduction to Coroutines3:56
Get an intuitive introduction to coroutines and understand how they differ from threads.
Kotlin Prerequisites — What You Need Before We Begin9:18
Review the Kotlin concepts needed to follow the coroutine examples throughout the course.

Fibonacci and Sequences — Why Lazy Evaluation Matters10:00
Use Fibonacci to understand sequences and why lazy evaluation matters.
Sequence Builders — sequence { }, yield, and Lazy Pipelines13:22
Learn how sequence builders work and how yield enables lazy value production.
Sequences Summary — Everything We've Learned So Far3:20
Suspension in Action9:08
See suspension in action and understand what happens when a function pauses and resumes.
The suspend Keyword - What It Really Means5:00
Go beyond the syntax and understand what the suspend keyword actually represents.
Introduction to Continuations4:14
Get introduced to continuations and their role in suspended execution.
How Suspend works Internally8:28
Explore what Kotlin does internally when a function is marked suspend. Explore suspension points.
Resuming Coroutines — How a Paused Coroutine Comes Back to Life7:12
Follow the journey of a suspended coroutine as it resumes execution.
Resuming with Values — How resume(value) Flows Back into the Coroutine5:03
Returning values through continuations
Continuation Internals9:25
Take a closer look at the internal structure and behavior of continuations.
Continuation Implementation — Building the State Machine by Hand10:49
Build a simple state machine manually to understand how suspension can be implemented.
The Continuation State Machine - State transitions13:59
Connect everything together and see how Kotlin represents suspended execution as a state machine.

Introduction to Coroutine Builders4:21
Understand coroutine builders and how they are used to launch concurrent work.
The launch Builder16:19
Learn how launch starts concurrent work and returns a Job to control it.
The async Builder — Concurrent Work That Returns a Value8:55
Learn how async performs concurrent work and produces a result.
Parent-Child Relationships — How Coroutines Track Each Other10:40
Understand how coroutines form parent-child relationships and why this matters.
Jobs — The Lifecycle Handle of Every Coroutine4:17
Explore Job and how it represents and controls a coroutine's lifecycle.
Job states and How Parents Track Children10:18
See what job states are. See how parent coroutines track their children and coordinate their completion.
Introduction to Structured Concurrency6:23
Learn the core principles of structured concurrency and why coroutine lifecycles should be structured.
coroutineScope — Grouping Concurrent Work and Waiting for It6:01
Learn how coroutineScope groups concurrent work and waits for all its children.
supervisorScope — Isolating Child Failures from Siblings7:18
Learn how supervisorScope prevents one child's failure from automatically cancelling its siblings.
runBlocking and Structured Concurrency — The Bridge and the Rules5:57
Understand how runBlocking bridges blocking code with coroutines and how it relates to structured concurrency.

Coroutine Context — The Environment Every Coroutine Carries3:25
Understand what a coroutine context is and the information it carries.
CoroutineContext Mechanics & Code20:12
Explore how CoroutineContext is built, combined, and accessed in code.
Dispatchers — Deciding Which Thread Your Coroutine Runs On3:13
Learn how dispatchers determine where coroutine code executes.
Dispatchers Code Deep Dive13:16
Put dispatchers into practice and observe how they affect coroutine execution.
What is a CoroutineScope ?5:20
Why do we need scope functions ?8:04
Creating a Custom Scope7:52

Parent-Child Cancellation Mechanics9:54
Understand how cancellation propagates between parent and child coroutines.
The finally Block — Cleaning Up When a Coroutine Is Cancelled4:30
Learn how finally ensures cleanup when a coroutine is cancelled.
Cooperative Cancellation8:11
Understand why coroutine cancellation is cooperative and how coroutines respond to cancellation.
Stopping Coroutines11:14
Learn the practical ways to cancel and stop running coroutines.
Comparing Cancellation Mechanisms3:32
Compare different cancellation approaches and understand when each is appropriate.
How Cancellation Flows Down the Coroutine Hierarchy8:01
Trace cancellation as it propagates from parents to their children.
Nested Cancellation3:43
Explore cancellation in nested coroutine scopes and see how cancellation propagates through multiple levels.
CancellationException Handling10:59
Understand CancellationException and how cancellation should be handled correctly.

Introduction to Kotlin Flow9:50
Sequence vs Flow2:18
What is a Flow ?5:13
Flow Mental Model4:04
Flow Builders and collect6:37
Flow Internals7:24
Flow Internal Design3:42
flowOf and asFlow4:19
Emit Mechanics5:13
Flow Suspension Mechanics3:00
collectLatest Operator4:48
Terminal Operators3:58
Concurrent Emissions3:27
Operator Pipeline Mechanics3:45
Operator Internals6:03
flowOn and Context Preservation10:48
BackPressure and Exceptions5:53
Flow Cancellation4:00
The transform Operator5:02

The merge Operator5:03
The zip Operator7:02
The combine Operator6:28
Flattening Operators9:29
The catch Operator5:36
Flow Exception Handling Patterns9:15
The buffer Operator6:10
debounce and sample Operators4:12
Introduction to MutableSharedFlow8:54
SharedFlow Implementation3:29
SharedFlow Internals5:11
Replay Cache Mechanics2:18
SharedFlow Overview and Use Cases9:10
Introduction to StateFlow4:07
StateFlow Implementation7:19
The shareIn Operator8:46
shareIn Parameters and Strategies7:57
The stateIn Operator4:41

Requirements

Basic knowledge of Kotlin programming, including functions, lambdas, and object-oriented programming. No prior coroutine experience is required.

Description

Kotlin Coroutines and Flow are powerful, but simply learning their APIs is not enough. To use them confidently, you need to understand what actually happens when a coroutine suspends, resumes, runs concurrently, gets cancelled, or encounters an exception.

This course takes a deep, conceptual approach to Kotlin Coroutines and Flow. Instead of focusing on memorizing functions and APIs, you'll build a strong mental model of how they work and, more importantly, why they behave the way they do.

You'll begin by understanding the problems with traditional threads, blocking operations, and concurrent programming, and why coroutines provide a lightweight and scalable approach to concurrency. You'll then explore suspension, continuations, suspension points, and coroutine state machines to understand what the suspend keyword really means and what happens when a coroutine pauses and resumes.

From there, you'll learn coroutine builders, Jobs, parent-child relationships, structured concurrency, CoroutineScope, CoroutineContext, dispatchers, cancellation, and exception handling through practical examples and execution-focused explanations.

The course then moves into Kotlin Flow, where you'll develop a clear understanding of cold flows, collection, emission, operators, context preservation, flowOn, cancellation, exceptions, combination, flattening, SharedFlow, StateFlow, shareIn, and stateIn.

Throughout the course, concepts are introduced using a problem → why → solution approach, helping you understand not only how to use an API, but why it exists.

By the end of the course, you won't just have a collection of Coroutine and Flow APIs. You'll have the mental model needed to reason about, debug, design, and use concurrent Kotlin applications with confidence.

Who this course is for:

Anyone with basic Kotlin programming knowledge who wants to understand how coroutines work, why they matter, and what happens under the hood.

Kotlin Coroutines & Flow: Learn How They Really Work

What you'll learn

Explore related topics

Course content

Foundations & The Problem Concurrency Solves5 lectures • 26min

Sequences, Suspension & Continuations Under the Hood12 lectures • 1hr 40min

Coroutine Builders and Structured Concurrency10 lectures • 1hr 20min

Context, Dispatchers and Scope7 lectures • 1hr 1min

Cancellation Mechanics8 lectures • 1hr

Exception Handling in Structured Hierarchies5 lectures • 46min

Kotlin Flow Core Mechanics19 lectures • 1hr 39min

Advanced Flow Operators, SharedFlow & StateFlow18 lectures • 1hr 55min

Requirements

Description

Who this course is for: