CF

Kotlin Coroutines and Concurrency

10h 8m 19s
English
Paid

This course helps you build a clear, simple mental model of Kotlin coroutines. You will stop guessing why your code works and learn how to use coroutines with confidence.

Why Coroutines Feel Hard

Many developers use coroutines but do not fully understand them. You may write code that you hope works, or avoid coroutines because they feel risky. This often happens when you learn from random posts or talks.

Topics like async code, shared state, context, and scope can look complex when you meet them all at once. Without a clear path, it is easy to feel lost.

How This Course Helps

The course gives you a slow and steady path. Each topic builds on the last one. You learn one idea at a time. You see how coroutines work and why they behave as they do.

You do not need to guess or fill gaps on your own. You get a full picture from start to finish.

What You Will Learn

Clear Concepts

You learn key ideas with simple examples. This helps you see coroutines as a tool, not as magic.

Practical Skills

You learn to write async and concurrent code that you can trust. You learn how to avoid common errors and how to find issues fast.

About the Author: Dave Leeds

Dave Leeds thumbnail

Dave Leeds is a US Kotlin developer and educator focused on the Kotlin language at depth — particularly the concurrency and coroutines model that makes Kotlin distinctive among modern JVM languages.

His CourseFlix listing carries Kotlin Coroutines and Concurrency — a focused treatment of Kotlin's coroutine model, structured concurrency, the dispatcher landscape, flow / channels, and the patterns for writing safe concurrent Kotlin code.

Material is paid and aimed at Kotlin developers building concurrent applications, particularly on the Android and server-side Kotlin tracks. For broader content, see CourseFlix's Mobile Apps Development category page.

Watch Online 57 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 57 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Coroutines Lunch & Learn Presentation
All Course Lessons (57)
#Lesson TitleDurationAccess
1
Coroutines Lunch & Learn Presentation Demo
30:22
2
Intro to Coroutines and Concurrency
13:43
3
Suspending Functions
08:42
4
Coroutines in the Standard Library
12:25
5
You'll Need a Scope...
08:08
6
Coroutine Builders: launch() and async()
10:07
7
Threads and Dispatchers
06:57
8
Coroutine Context
04:54
9
Ways to Get a Scope
05:42
10
Introduction to Shared Mutable State
06:14
11
Avoiding Shared Mutable State
07:34
12
Confinement
08:10
13
Mutex Locks
06:17
14
Atomics
05:17
15
Structured Programming and Structured Concurrency
07:44
16
Creating Structured Concurrency
11:35
17
Scopes and Suspending Functions
15:00
18
Structured Concurrency in Practice
12:23
19
Cancellations
07:39
20
Managing Cancellations
12:38
21
Exceptions in Coroutines
10:17
22
Supervisors
09:50
23
CoroutineExceptionHandler
09:32
24
Avoiding Unnecessary Coroutines
13:37
25
Attaching a Scope to a Lifecycle
11:23
26
Passing Scopes and Dispatchers
10:18
27
Wrapping Callback-Based APIs
08:31
28
Characteristics of Collections and Sequences
10:43
29
Flows, Collectors, and Emitters
12:20
30
Flow Operators
11:49
31
Flow and Cancellations
10:07
32
Flow and Exceptions
10:46
33
Intro to Multi-Coroutine Flows
09:45
34
Multi-Coroutine Flow Operators
15:01
35
Putting Flows Together
09:08
36
Flattening Flows
07:40
37
Introduction to Hot Flows
04:11
38
SharedFlow
15:48
39
StateFlow
10:50
40
Converting Cold Flows into Hot Flows
13:02
41
Intro to Workflows
07:16
42
Channel Basics
12:06
43
Complex Workflows
08:04
44
Produce and Select
08:23
45
Actors
10:41
46
Terminating Channels
14:33
47
Channels and Flows
10:32
48
Basics of Testing Concurrent Code
09:09
49
Controlling Time in Tests
12:59
50
Testing Coroutines on External Scopes
15:08
51
Testing Flows
15:16
52
Debugging with Coroutine IDs and Names
08:32
53
Debugging Coroutines in the IDE
12:23
54
The Coroutines Debugging Library
13:18
55
Coroutines in Spring Framework
09:50
56
Coroutines in Ktor Server and Client
11:05
57
Coroutines in Compose Apps
12:55
Unlock unlimited learning

Get instant access to all 56 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Books

Read Book Kotlin Coroutines and Concurrency

#TitleTypeOpen
1Chapter 20 - Coroutine Essentials PDF
2Field Guide to Kotlin Terms PDF
3Preventing Race Conditions in Coroutines PDF
4Coroutines - Mental Model - Printer Friendly PDF
5Coroutines - Mental Model PDF

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course is designed for developers who have a basic understanding of Kotlin and programming concepts. Familiarity with asynchronous programming, although not mandatory, can be beneficial. The course builds on these foundations to introduce concepts related to Kotlin coroutines and concurrency.
What practical skills will I acquire upon completing the course?
You will learn to write reliable async and concurrent code using Kotlin coroutines. The course covers how to effectively use coroutine builders like 'launch()' and 'async()', manage coroutine contexts, and handle exceptions, cancellations, and shared mutable state. These skills will help you avoid common errors and debug issues efficiently.
Who is the target audience for this course?
The course is aimed at Kotlin developers who want to deepen their understanding of coroutines and concurrency. It is ideal for those who have tried using coroutines but feel uncertain about their code or want to refine their knowledge and skills in managing concurrent programming tasks.
How does the depth of this course compare to other courses on Kotlin concurrency?
This course offers a structured and detailed exploration of Kotlin coroutines, focusing on building a clear mental model. It progresses from foundational concepts like suspending functions and coroutine context to advanced topics such as multi-coroutine flows and debugging. This progression ensures a comprehensive understanding, contrasting with courses that might provide a more fragmented overview.
What specific tools or platforms will I learn to use in this course?
You will learn to use coroutine builders and contexts, as well as tools like mutex locks and atomic operations for managing shared mutable state. The course also covers how to implement coroutines in frameworks such as the Spring Framework, Ktor Server and Client, and Compose Apps.
What topics are not covered in this course?
The course does not cover the basics of Kotlin programming or general asynchronous programming, assuming that participants already have foundational knowledge in these areas. It also does not delve into non-Kotlin concurrency models or frameworks outside those specifically supported by Kotlin coroutines.
How can the skills learned in this course benefit my career?
Mastering Kotlin coroutines and concurrency can significantly enhance your ability to write efficient, scalable, and maintainable code. These skills are highly valued in industries that require robust backend systems and responsive user interfaces, thereby opening opportunities in various sectors such as mobile and web development, cloud computing, and enterprise software.