Project with exercises

Coroutines on Android (and other frontend platforms)

Thread switching

Callbacks

RxJava and other reactive streams

Using Kotlin Coroutines

Coroutines on the backend

Conclusion

Real-life usages

Exercise: Factorial sequence

Exercise: Prime numbers sequence

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

Continuation-passing style

A very simple function

A function with a state

A function resumed with a value

The call stack

The actual code

The performance of suspending functions

Summary

Exercise: What is stored by a continuation?

Asynchronous coroutine builders

Blocking coroutine builders

Structured Concurrency

Coroutine scope functions

Summary

Exercise: Showing user details

Exercise: Finding the best student

Exercise: CommentService

Exercise: mapAsync

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

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

Job and relationships

Coroutine lifecycle

Awaiting job completion

The Job factory function

Synchronizing coroutines

Summary

Basic cancellation

The finally block

invokeOnCompletion

Cancellation of children

Cancellation in a coroutine scope

Just one more call

Stopping the unstoppable

CancellationException does not propagate to its parent

withTimeout

suspendCancellableCoroutine

Summary

Exercise: Correct mistakes with cancellation

Exceptions and structured concurrency

SupervisorJob

Do not use SupervisorJob as a builder argument

supervisorScope

Do not use withContext(SupervisorJob())

Exceptions and await call

CoroutineExceptionHandler

Summary

CoroutineScope factory function

Constructing a background scope

Constructing a scope on Android

Summary

Exercise: NotificationSender

Exercise: BasePresenter

Blocking synchronization

Atomics

A dispatcher limited to a single thread

Mutex

Semaphore

Summary

Exercise: UserDownloader

Exercise: CompanyDetailsRepository

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

Replacing the main dispatcher

Testing Android functions that launch coroutines

Setting a test dispatcher with a rule

Summary

Exercise: Testing a suspending function

Exercise: Testing mapAsync

Exercise: Testing the NotificationSender class

Exercise: Testing a View Model

Channel types

On buffer overflow

On undelivered element handler

Fan-out

Fan-in

Pipelines

Practical usage

Summary

Selecting deferred values

Selecting from channels

Summary

Exercise: raceOf

Hot vs cold

Hot channels, cold flow

Summary

Comparing flow to other ways of representing values

The characteristics of Flow

Flow nomenclature

Real-life use cases

Summary

Understanding Flow

How Flow processing works

Flow is synchronous

Flow and shared state

Conclusion

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

onEach

onStart

onCompletion

onEmpty

catch

Uncaught exceptions

retry

flowOn

launchIn

Summary

Exercise: NewsViewModel

map

filter

take and drop

How does collection processing work?

merge, zip and combine

fold and scan

flatMapConcat, flatMapMerge and flatMapLatest

Distinct until changed

Terminal operations

Summary

Exercise: ProductService

Exercise: Flow Kata

Exercise: MessageService

SharedFlow

shareIn

StateFlow

stateIn

Summary

Exercise: LocationService

Exercise: PriceService

Exercise: NewsViewModel using shareIn

Transformation functions

Testing infinite flows

Determining how many connections were opened

Testing view models

Summary

Exercise: Flow testing

Data/Adapters Layer

Callback functions

Blocking functions

Observing with Flow

Domain Layer

Concurrent calls

Flow transformations

Presentation/API/UI layer

Creating custom scope

Using runBlocking

Working with Flow

Summary

Threads on different platforms

Transforming suspending into non-suspending functions

Transforming suspend functions into blocking functions

Transforming suspend functions into callback functions

Platform-specific options

Calling suspending functions from other languages

Flow and Reactive Streams

Summary

Don’t use async with an immediate await

Use awaitAll

Suspending functions should be safe to call from any thread

Use Dispatchers.Main.immediate instead of Dispatchers.Main

Remember to use yield in heavy functions

Understand that suspending functions await completion of their children

Understand that Job is not inherited: it is used as a parent

Don’t break structured concurrency

Use SupervisorJob when creating CoroutineScope

Consider cancelling scope children

Before using a scope, consider under which conditions it is cancelled

Don’t use GlobalScope

Avoid using Job builder, except for constructing a scope

Functions that return Flow should not be suspending

Prefer a suspending function instead of Flow when you expect only one value

Exercise solutions