Kotlin Multiplatform. Advanced multithreading

Transcript

1. Kotlin Multiplatform. Advanced multithreading Anna Zharkova Lead Mobile developer
2. Introduction • Mobile developer since 2013 • Lead Mobile developer in «Usetech software» . • Native mobile development, iOS and Android (Swift/Objective-C, Kotlin/Java) cross-platform mobile development (Xamarin, Kotlin multiplatform) • Leading mobile team. Mentorship • Public speaking (Mobius Moscow 2020, AppsLive 2020) • Tutor in Otus (iOS advanced) • Writing articles about mobile development (especially iOS and KMM ) • Women Techmaker Ambassador since 2021 2
3. Goals. Today discuss: • Kotlin Multiplatform and common concurrency • Coroutines, solving problems in Kotlin/Native • Concurrency without coroutines. Background Workers • Advanced Sharing • Flows & Kotlin/Native, iOS side 3
4. Kotlin Multiplatform 4
5. Kotlin Multiplatform 5 • SDK, not framework • JVM for Android and LLVM for iOS • Total sharing (almost)
6. Every platform needs its Kotlin 6 Kotlin Common Kotlin JVM Kotlin JS Kotlin Native
7. Concurrency in Kotlin/Native 7 expect Dispatchers iOS: actual Dispatchers Android: actual Dispatchers Kotlin Native Kotlin JVM Kotlin JVM concurrency != Kotlin Native concurrency
8. Networking as a case Common implementation (e.g. use Ktor) -> Coroutines Separated native -> Coroutines, native concurrency 8 Depends on app architecture
9. Sample. Networking with Ktor and Coroutines 9 Common concurrency with Coroutines Ktor implements async work under its hood
10. Coroutines vs GCD. Suspended 10 Suspended not blocking in iOS Suspended Kotlin easy transforms into Swift (since Kotlin Native 1.4)
11. Problem of common architecture 11 Network service API service Common architecture iOS View Android View Common Work with coroutines Common architecture = common scope
12. Setting up thread and contexts 12 Android/ iOS : Dispatchers.Default (Android) Dispatchers.Main – unique for platform
13. Dispatchers.Main inside 13 Dispatchers factory in MainCoroutineDispatcher MainDispatchers.kt
14. Let’s focus in Kotlin/Native Kotlin/JVM is OK 14
15. Setting up thread and contexts 15 iOS: using Default dispatcher Something went wrong
16. Missed Dispatchers in iOS 16 No default dispatcher for iOS https://github.com/Kotlin/kotlinx.coroutines/issues/470
17. Missed Dispatchers in iOS 17 Issue 462 still be not solved https://github.com/Kotlin/kotlinx.coroutines/issues/462
18. CoroutineDispatcher for iOS 18 iOS: own CoroutineDispatcher to be used as a context
19. CoroutineDispatcher for iOS 19 Not available to create working dispatcher bound to DispatchersQueue background We have to use Main as default (Dispatchers.Default not working)
20. CoroutineDispatcher for iOS 20 Use MainDispatcher block.run().freeze()???
21. How to work with threads in Kotlin/Native 21 • Mutable == for one thread • Immutable == multiple thread In Kotlin JVM everything is already done
22. How to work with threads in Kotlin/Native 22 Object should be freezed to become immutable https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.native.concur rent/freeze.html
23. How to work with threads in Kotlin/Native 23 Background could be called like this
24. Why not to use GlobalScope 24 Default background work? Not recommended Potential leaks and losing of callbacks ^ l Fix
25. Immutable problems 25 Singletones and constants are frozen by default
26. Immutable problems 26 Use @ThreadLocal for objects
27. Immutable problems 27 Use @ThreadLocal for objects
28. It can be not only Coroutines 28
29. Different synchronization 29 Collections, thread-safe read write
30. Deal without coroutines 30 Sample: Networking without Ktor and Coroutines
31. Deal with workers 31 iOS Http Client with Kotlin
32. Deal with workers 32 iOS Http Client with Kotlin ßBackground <- Main
33. Worker. Background 33 Do background with Worker Don’t forget to share (freeze)!
34. Worker. Background 34 Apply to code What about return to main?
35. Worker. Background 35 Worker with return Problem: Same thread. How to switch to main??? <- return
36. Rout to Main 36 Dispatch_queue_main + freeze() Don’t forget to apply main{} to code! <- return
37. Sharing data and variables 37 Everything to share should be freezed InvalidMutabilityException: mutation attempt of frozen
38. Still crashes We’ve forgot to deal with mutables 38
39. Sharing data and variables 39 Crash!!!! InvalidMutabilityException: mutation attempt of frozen
40. Sharing data and variables 40 @ThreadLocal – objects and backing fields only!
41. Sharing data and variables 41 ThreadLocal without annotation (attempt) Inspired by https://github.com/ktorio/ktor
42. Sharing data and variables 42 Freeze exception Not working without freeze
43. Sharing data and variables. Atomic 43 AtomicReferece wrapper Potential leaks
44. Sharing data and variables.Atomic 44 AtomicReferece wrapper Fix leaks
45. Sharing data and variables 45 DetachedObjectGraph Attach only once!
46. If it’s too complicated, let’s return to coroutines 46
47. Other ways to communicate between contexts 47 kotlinx.coroutines • Channels • Flows • CompletableDeffered
48. Other ways to communicate between contexts 48 kotlinx.coroutines • Channels • Flows • CompletableDeffered
49. Other ways to communicate between contexts 49 kotlinx.coroutines • Channels • Flows • CompletableDeffered
50. Other ways to communicate between contexts 50 kotlinx.coroutines • CompletableDeffered Also solves problem with lambdas sharing
51. Flow & iOS 51
52. Flow in Kotlin Common 52 Asynchronous flow instead of LiveData (LiveData is Android only!)
53. Flow in Kotlin Common 53 Looks strange in iOS side
54. Flow in Kotlin Common 54 Need to use own collector Sometimes signals are missed
55. Flow in Kotlin Common 55 Use custom flow wrapper
56. Flow in Kotlin Common 56 Should be called in coroutines scope Even remove of flowOn doesn’t solve problem
57. Flow in Kotlin Common 57 Flows should be used directly in common part Or we need to make a wrapper on iOS side
58. Flow in Kotlin Common 58 Flows -> Publishers https://gist.github.com/Nillerr/dc437c0248 5da661b4f285cee01069a1
59. Summary. 59 • It hard to work with concurrency in KMM, but you could work with id. • KMM still be improved • Kotlin/Native still be improved –> wait for issue 462 to be solved
60. Sources 60 • https://betterprogramming.pub/using-kotlin-flow-in-swift-3e7b53f559b6 • https://github.com/JetBrains/kotlin-native • https://github.com/JetBrains/kotlin-native/blob/master/IMMUTABILITY.md • https://github.com/Kotlin/kotlinx.coroutines/issues/462 • https://github.com/anioutkazharkova/kmm-concurrency-helper • https://kmpdocs.suparnatural.com/concurrency/#worker • https://elizarov.medium.com/the-reason-to-avoid-globalscope-835337445abc
61. Thanks for listening! 61 @anioutkajarkova azharkova prettygeeknotes