KMM new memory management

Transcript

1. Kotlin Native: Dealing with old & new memory models 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 • 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 We can use default dispatchers for IOS also
16. Setting up thread and contexts 16 But in some cases something goes wrong
17. CoroutineDispatcher for iOS 17 iOS: own CoroutineDispatcher to be used as a context
18. Setting up thread and contexts 18 Problem is not solved!!!
19. CoroutineDispatcher for iOS 19 Not available to create working dispatcher bound to DispatchersQueue background For Ktor we can use MainDispatcher
20. CoroutineDispatcher for iOS 20 Use own dispatchers 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 Could be called as usual suspend even in iOS side
57. New memory management model 57
58. What’s new 58 Support safe sharing and chage of thread contexts: 1. Multithreading without freeze() 2. AtomicReferences/ FreezableAtomicReference without leaks 3. No need of ShareImmutable when use globals 4. Worker.execute doesn’t return isolated graph of dependencies
59. What’s new 59 1. Atomic references need freeze(). Use FreezableAtomicReference instead 2. Lazy globals. @'EagerInitialization for immediate initialization 3. No guarantee that suspend returns to main 4. Deinit could be called in other thread
60. Migration 60 Kotlin 1.6.0-M1 or newer Need Xcode 12.5 or newer
61. Let’s remove all freeze() 61 Remove all freeze()-blocks from non- coroutine version
62. Let’s remove all freeze() 62 Remove all freeze()-blocks from your code
63. Let’s remove all freeze() 63 Even from flows
64. Atomic references 64 Change all atomic reference to freezable atomic references
65. Atomic references 65 Also remove freezing in code for atomics
66. Use default dispatchers 66 Let’s change dispatchers to default
67. Use logic with main thread 67 It also could be useful to add autoreleasepool in order to prevent memory leaks!
68. New single thread context 68 Previously it could be used only for JVM
69. Prevent Freezing exceptions 69 Libraries without support of new memory model could cause leaks
70. Summary. 70 • Concurrency in Kotlin Native could be really hard • But there is full toolkit to provide this • New memory management model is going to solve all our pains • There will be improvements with leaks and garbage collection
71. Sources 71 • 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/JetBrains/kotlin/blob/master/kotlin-native/NEW_MM.md • https://github.com/anioutkazharkova/kmm-concurrency-helper • https://kmpdocs.suparnatural.com/concurrency/#worker • https://elizarov.medium.com/the-reason-to-avoid-globalscope-835337445abc
72. Thanks for listening! 72 @anioutkajarkova azharkova prettygeeknotes