Kotlin Coroutines:
Deep Dive
Kotlin coroutines have revolutionized JVM development, especially on Android and the backend, as they let us easily implement efficient and reliable multithreading. Their cutting-edge design and features are ideally suited to modern use cases. In this book, we will explore how Kotlin coroutines work and how we can use them to improve our applications – using both the built-in support and the kotlinx.coroutines library.
This is a practical book. It shows everything with examples and focuses on real-life use cases. As this technology is already widely used on Android and backend applications, we will see how we can use it there and what the best practices are.
The purpose
The importance of concurrency is growing, but the classic techniques are not enough. Current trends suggest that coroutines are where our industry is clearly heading, and Kotlin coroutines are a very solid step in the right direction. Let me show them to you, with examples of how well they help in common use cases. I hope you will have a lot of fun reading this book.
Chapter by Chapter
Clear path to progress
1.Introduction
- Who is this book for?
- The structure of this book
- What will be covered?
- The Kotlin for Developers series
- Conventions
- Code conventions
- Version
- Exercises and solutions
- Acknowledgments
2.Why Kotlin Coroutines?
- Simplicity
- Performance
- Cancellation
- Synchronization
- Testability
- Flow
- Coroutines are multiplatform
- The biggest problem with Kotlin Coroutines
- Summary
3.Sequence builder
- Real-life usages
- Exercise: Factorial sequence
- Exercise: Prime numbers sequence
4.How does suspension work?
- A game analogy
- Suspending functions
- Your first suspension
- What is stored in the continuation?
- Delaying a coroutine
- Resuming with a value
- Resume with an exception
- Suspending a coroutine, not a function
- Summary
- Exercise: Callback function wrappers
- Exercise: Continuation storage
5.Coroutines under the hood
- Continuation-passing style
- A very simple function
- A function with a state
- A function resumed with a value
- The call stack
- Suspending functions in other contexts
- The actual code
- The performance of suspending functions
- Summary
- Exercise: What is stored by a continuation?
6.Coroutines: built-in support vs library
7.Starting coroutines
- Asynchronous coroutine builders
- Blocking coroutine builders
- Structured Concurrency
- Coroutine scope functions
- Summary
- Exercise: UserDetailsRepository
- Exercise: BestStudentUseCase
- Exercise: CommentService
- Exercise: mapAsync
8.The bigger picture
9.Coroutine context
- CoroutineContext interface
- Finding elements in CoroutineContext
- Adding contexts
- Empty coroutine context
- Subtracting elements
- Folding context
- Coroutine context and builders
- Accessing context in a suspending function
- Changing context in suspending functions
- Creating our own context
- Coroutines and thread elements
- Summary
- Exercise: Understanding context propagation
- Exercise: CounterContext
10.Dispatchers
- Default dispatcher
- Limiting the default dispatcher
- Main dispatcher
- IO dispatcher
- Dispatcher with a custom limit
- Dispatcher with a fixed pool of threads
- Dispatcher limited to a single thread
- Using virtual threads from Project Loom
- Unconfined dispatcher
- Immediate main dispatching
- Continuation interceptor
- Performance of dispatchers when executing different tasks
- Summary
- Exercise: Using dispatchers
- Exercise: DiscNewsRepository
- Exercise: Experiments with dispatchers
11.Job and coroutine lifecycle
- Job and relationships
- Coroutine lifecycle
- Awaiting job completion
- The Job factory function
- Synchronizing coroutines
- Summary
12.Cancellation
- Basic cancellation
- The finally block
- invokeOnCompletion
- Cancellation of children
- Cancellation in a coroutine scope
- Just one more call
- Stopping the unstoppable
- CancellationException is special
- CancellationException does not propagate to its parent
- withTimeout
- suspendCancellableCoroutine
- Summary
- Exercise: Correct mistakes with cancellation
13.Exception handling
- Exceptions and structured concurrency
- SupervisorJob
- supervisorScope
- Exceptions and await call
- CoroutineExceptionHandler
- Summary
14.Constructing a coroutine scope
- CoroutineScope factory function
- Constructing a background scope
- Constructing a scope on Android
- Summary
- Exercise: NotificationSender
- Exercise: BaseViewModel
15.Synchronizing access to mutable state
- Using atomic values
- Synchronized blocks
- Using a dispatcher limited to a single thread
- Mutex
- Semaphore
- Summary
- Exercise: CompanyDetailsRepository
- Exercise: CancellingRefresher
- Exercise: TokenRepository
- Exercise: Suspended lazy
- Exercise: mapAsync with concurrency limit
16.Testing Kotlin Coroutines
- Testing time dependencies
- TestCoroutineScheduler and StandardTestDispatcher
- runTest
- Background scope
- Testing cancellation and context passing
- UnconfinedTestDispatcher
- Using mocks
- Testing functions that change a dispatcher
- Testing what happens during function execution
- Testing functions that launch new coroutines
- Testing classes that need scope in runTest
- Replacing the main dispatcher
- Testing Android functions that launch coroutines
- Setting a test dispatcher with a rule
- Summary
- Exercise: Test UserDetailsRepository
- Exercise: Testing mapAsync
- Exercise: Testing the NotificationSender class
- Exercise: Testing a View Model
17.Channel
- Channel types
- On buffer overflow
- On undelivered element handler
- Fan-out
- Fan-in
- Pipelines
- Practical usage
- Summary
- Exercise: UserRefresher
- Exercise: Cafeteria simulation
18.Select
- Selecting deferred values
- Selecting from channels
- Summary
- Exercise: raceOf
19.Hot and cold data sources
- Hot vs cold
- Hot channels, cold flow
- Summary
20.Flow introduction
- Comparing flow to other ways of representing values
- The characteristics of Flow
- Flow nomenclature
- Real-life use cases
- Summary
21.Understanding Flow
- Understanding Flow
- How Flow processing works
- Flow is synchronous
- Flow and shared state
- Conclusion
22.Flow building
- Flow from raw values
- Converters
- Converting a function to a flow
- Flow and Reactive Streams
- Flow builders
- Understanding flow builder
- channelFlow
- callbackFlow
- Summary
- Exercise: Flow utils
- Exercise: All users flow
- Exercise: distinct
23.Flow lifecycle functions
- onEach
- onStart
- onCompletion
- onEmpty
- catch
- Uncaught exceptions
- retry
- flowOn
- launchIn
- Summary
- Exercise: TemperatureService
- Exercise: NewsViewModel
24.Flow processing
- map
- filter
- take and drop
- How does collection processing work?
- merge, zip and combine
- fold and scan
- flatMapConcat, flatMapMerge and flatMapLatest
- Distinct until changed
- buffer and conflate
- debounce
- sample
- Terminal operations
- Summary
- Exercise: ProductService
- Exercise: Flow Kata
- Exercise: MessageService
25.SharedFlow and StateFlow
- SharedFlow
- shareIn
- StateFlow
- stateIn
- Summary
- Exercise: Update ProductService
- Exercise: Update TemperatureService
- Exercise: LocationService
- Exercise: PriceService
- Exercise: NewsViewModel using stateIn
26.Testing flow
- Transformation functions
- Testing infinite flows
- Determining how many connections were opened
- Testing view models
- Summary
- Exercise: Flow testing
27.Common use cases
- Data/Adapters Layer
- Domain Layer
- Presentation/API/UI layer
- Summary
28.Using coroutines from other languages
- Threads on different platforms
- Transforming suspending into non-suspending functions
- Calling suspending functions from other languages
- Flow and Reactive Streams
- Summary
29.Launching coroutines vs. suspending functions
- Best practices
30.Best practices
31.The End
32.Exercise solutions
33.Notes