Cracking Kotlin Coroutines

The presentation was held at Droidcon Italy 2022 and was accompanied with live coding with examples from this GitHub repo https://github.com/dahlbergbob/cracking-coroutines-droidcon-it

Transcript

1. Bob Dahlberg Cracking Kotlin Coroutines
2. Suspension Builders Scope Context Structured Concurrency Job Cancellation Exception Handling Streams* Cracking Kotlin Coroutines
3. Cheating
4. Cheating // clears the text field clear(optional:String = ””) // variants adds to the text field out(message:Any) // launches a coroutine viewModelScope.launch {}
5. Suspension
6. Suspension Suspension is one of the most central and fundamental part of Kotlin coroutines. Suspending is pausing Suspending is resuming Dividing the coroutine into smaller pieces
7. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
8. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
9. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
10. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
11. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
12. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
13. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
14. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
15. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
16. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
17. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
18. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
19. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
20. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) }
21. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) } // 0, 1, 6, 2, 4, 7, 3, 5
22. Suspension fun order() { out(0) viewModelScope.launch { out(1) launch { out(2) delay(100) out(3) } launch { out(4) delay(100) out(5) } out(6) } out(7) } // 0, 1, 6, 2, 4, 7, 3, 5
23. Suspension Lets look closer at the continuation in action with the suspendCancellableCoroutine function. fun simpleContinuation() { viewModelScope.launch { out(1) suspendCancellableCoroutine<Int> { out(2)
 it.resumeWith(Result.success(2)) } out(3) } }
24. Suspension Use suspendCancellableCoroutine instead of suspendCoroutine, Useful when bridging between callbacks and coroutines. They are suspending functions, and as all suspending functions - they need to be called from a suspending function, and so on. So where to start?
25. Builders
26. val job = launch { } val deferred = async { } Builders
27. Scope
28. Scope A very small interface, only holding a reference to the context. Don't be afraid to create them - they are not dangerous. Look at viewModelScope to see an example used a lot But don't overuse them
29. Context
30. Context Simpli fi ed - A HashMap of Contexts We need a context - it de fi nes the rules for our coroutine We can override any value of the context Job, Dispatchers, CoroutineExceptionHandler, CoroutineName to name a few
31. Structured concurrency
32. Structured concurrency An important and often overlooked part of coroutines. Our builders are extension functions to the CoroutineScope. Creating a new coroutine (invoking a builder) inherits the context and creates a parent/child relationship. Each coroutine awaits it’s children before completing
33. Job
34. Job Has a lifecycle dictating the state Each coroutine has it’s own job! It’s the only context that isn’t inherited 
 - each coroutine creates Its own instance with the inherited as its parent. Creating the hierarchy needed for structured concurrency
35. Job Has a lifecycle dictating the state Each coroutine has it’s own job! It’s the only context that isn’t inherited 
 - each coroutine creates Its own instance with the inherited (or overridden) as its parent. Creating the hierarchy needed for structured concurrency
36. Job wait children +-----+ start +--------+ complete +-------------+ finish +-----------+ | New | -----> | Active | --------> | Completing | -------> | Completed | +-----+ +--------+ +-------------+ +-----------+ | cancel / fail | | +----------------+ | | V V +------------+ finish +-----------+ | Cancelling | -------------------------------> | Cancelled | +------------+ +-----------+
37. Cancellation
38. Cancellation Propagation Tidying up Collaborative Rules
39. Exceptions
40. Exceptions Propagation Tidying up Rules CoroutineExceptionHandler
41. Streams
42. Streams Flows Flows adhere to the general cooperative cancellation of coroutines. As usual, fl ow collection can be cancelled when the fl ow is suspended in a cancellable suspending function (like delay). Channels Note: Ticker channels are not currently integrated with structured concurrency and their api will change in the future.
43. Sum up
44. Suspension
 - They de fi ne the units of code
 - suspendCancellableCoroutine
 - Can only be called from other suspending functions Scope
 - They are the logical root of coroutines
 - Needed for builders
 - Cancel children, not the scope
 - Think of viewModelScope when in doubt. Structured concurrency
 - Understand it! Utilize it!
 - Even children with di ff erent dispatchers are awaited
 - Don’t think in callbacks. Job
 - The controller of structured concurrency
 - Understand the lifecycle
 - Be ware of creation to not outplay the structure
 - One coroutine - One Job Sum up
45. Cancellation
 - They are collaborative - on suspension
 - Remember to re-trow them Exceptions
 - SupervisorJob / Job di ff erences
 - Use supervisorScope instead of creating jobs.
 - Propagates to the root (scope’s handler)
 - withContext(NonCancellable) Streams
 - Flows are built on top of coroutines
 - Channels are used to communicate between coroutines
 - Channels can’t broadcast
 - Mind context and use fl owOn
 - Think about order when collecting fl ows Sum up
46. Essentially: the Job is key,
 honouring structured concurrency,
 and grasping the suspending mechanism Sum up
47. Thank you
48. Questions? Thank you! Bob Dahlberg medium.com/dahlbergbob @mr_bob