Threading Made Easy! A Busy Developer’s Guide to Kotlin Coroutines
•
0 likes•144 views
Kotlin Coroutines is a powerful threading library for Kotlin, released by JetBrains in 2018. At The New York Times, we recently migrated our core libraries and parts of our News app from RxJava to Kotlin Coroutines. In this talk we’ll share lessons learned and best practices to understand, migrate to, and use Kotlin Coroutines & Flows. In this presentation, you will learn: What Coroutines are and how they function How to use Kotlin Coroutines & Flows (with real world examples and demos) Where and why you should use Coroutines & Flows in your app How to avoid the pitfalls of Coroutines Kotlin Coroutines vs. RxJava Lessons learned from migrating to Kotlin Coroutines from RxJava in large legacy projects & libraries By the end of this talk, you will be able to apply Kotlin Coroutines to your own app, run the provided sample code yourself, and convince your team to give Kotlin Coroutines a try!
Recommended
More Related Content
What's hot
What's hot (20)
Similar to Threading Made Easy! A Busy Developer’s Guide to Kotlin Coroutines
Similar to Threading Made Easy! A Busy Developer’s Guide to Kotlin Coroutines (20)
Recently uploaded
Recently uploaded (20)
Threading Made Easy! A Busy Developer’s Guide to Kotlin Coroutines
- 1. Threading Made Easy! A Busy Developer’s Guide to Kotlin Coroutines & Flows Lauren Yew July 23rd, 2021 The New York Times
- 2. Let’s start with a caveat
- 3. Topics 1. What are Coroutines and how do they function 2. Coroutines & Flows in the Real World 3. Pitfalls & Troubleshooting 4. Migrating from RxJava to Coroutines ?
- 4. Topics 1. What are Coroutines and how do they function 2. Coroutines & Flows in the Real World 3. Pitfalls & Troubleshooting 4. Migrating from RxJava to Coroutines ?
- 5. How Coroutines Work • Light weight functions that can run on a pool of threads • Cheap to create (great parallel performance) and cancellable • Suspend will yield the thread and can start on same / another thread
- 8. How Coroutines Work zzz yield …. Thread 1
- 9. How Coroutines Work …. Poll Thread 1 Thread 2
- 10. • Can switch Dispatchers to change thread pools How Coroutines Work Main Thread Dispatchers.IO
- 11. • Can switch Dispatchers to change thread pools How Coroutines Work Main Thread Dispatchers.IO …. launch(Dispatcher.IO)
- 12. • Can switch Dispatchers to change thread pools How Coroutines Work Main Thread Dispatchers.IO !
- 13. • Can switch Dispatchers to change thread pools How Coroutines Work Main Thread Dispatchers.IO ! withContext(Dispatcher.Main)
- 14. • Can switch Dispatchers to change thread pools How Coroutines Work Main Thread Dispatchers.IO
- 15. Coroutine Basics – How does it work? Why does the coroutine code look synchronous? • All code within a suspend function or a CoroutineScope is synchronous • Asynchronous threading when you launch a new coroutine
- 16. Coroutine Basics – How does it work? Why does the coroutine code look synchronous? • All code within a suspend function or a CoroutineScope is synchronous • Asynchronous threading when you launch a new coroutine
- 17. Coroutine Basics – Rule #1 All suspend functions MUST be called from another suspend function or a CoroutineScope launch / async or runBlocking. Why?
- 18. Why do I need CoroutineScope? CoroutineScope • Wrapper around CoroutineContext(s) for parent / child coroutines CoroutineContext • Helps determine what Dispatcher you’re running on • Contains the Job of your coroutines • Handles Exceptions and Cancellations
- 19. Topics 1. What are Coroutines and how do they function 2. Coroutines & Flows in the Real World 3. Pitfalls & Troubleshooting 4. Migrating from RxJava to Coroutines
- 21. Backend Calls Load search results from backend API
- 22. Backend Calls
- 23. Backend Calls
- 26. Room
- 27. Room
- 29. Cancelling
- 30. Flows in the Real World
- 31. Flows w/ View Models Use StateFlow for UI hooks rather than LiveData
- 32. Flows w/ View Models Use viewModelScope.launch …
- 33. Flows w/ Compose Change StateFlow to Compose State
- 34. Make sure StateFlow is lifecycle aware Flows w/ Compose + Lifecycle
- 35. Flows w/ Views + Lifecycle …
- 36. What Flow type works best?
- 37. State Flow • Best for UI binding (Ex: Result<Loading, Error, Value>) • Always needs initial value • Can create StateFlow from Flow
- 38. Shared Flow • Useful for results emitted from multiple places • No initial value • StateFlow is a SharedFlow + initial value • Can control cache / replay
- 40. Shared Flow
- 41. Shared Flow
- 42. Callback Flows & suspendCancellable • Can emit updates from object callbacks within its scope • Use callbackFlow when you get more than one update • Use suspendCancellable for a single update • Example usage: waiting for location, callbacks from listeners (error / success) when have to include object listeners and override their callback methods (ex: Third Party API bridge into coroutines / flows)
- 44. CallbackFlow
- 46. Transform / Map / Filter • Flows have similar transform functions like RxJava • map, filter, etc. • onEach • combine (similar to RxJava merge)
- 48. Combine
- 49. Combine
- 50. Combine
- 51. Topics 1. What are Coroutines and how do they function 2. Coroutines & Flows in the Real World 3. Pitfalls & Troubleshooting 4. Migrating from RxJava to Coroutines
- 52. Global Scope • Use for launching top level coroutines that run for the entire application lifecycle ONLY • Up to developer to cancel individual Jobs • Can cause resource / memory leaks
- 53. Working with Lifecycle Scope • Cancellation of coroutines launched in scope is important
- 54. Working with Lifecycle Scope …
- 55. Working with Lifecycle Scope …
- 56. Working with Lifecycle Scope • ViewModelScope automatically handles cancellation • UI LifecycleScope is more difficult
- 57. Working with Lifecycle Scope • lifecycleScope.launchWhenStarted, <StateFlow>.collectAsState.
- 58. Working with Lifecycle Scope • lifecycleScope.launchWhenStarted, <StateFlow>.collectAsState • Instead use: Lifecycle.repeatOnLifecycle / Lifecycle.flowWithLifecycle
- 59. Blocking Threads • RULE: All suspend functions should not block the caller thread • Anytime you have a blocking function, make sure to wrap it in a non- blocking suspend function • Use withContext(Dispatcher.IO)
- 60. Unit Testing • Pass CoroutineDispatcher in constructors
- 61. Unit Testing • Pass CoroutineDispatcher in constructors • Use TestCoroutineDispatcher • Use runBlockingTest • Debugging
- 62. Topics 1. What are Coroutines and how do they function 2. Coroutines & Flows in the Real World 3. Pitfalls & Troubleshooting 4. Migrating from RxJava to Coroutines
- 63. The New York Times w/ RxJava & Coroutines NYT Android News App After 3 months of work, we migrated our core feature libraries from RxJava into Kotlin Coroutines and integrated them with our News app. Our app and libraries are faster and more reliable because of it.
- 64. Performance Comparisons An example of results from one of our larger core library migrations This sample should not be taken as a generalization. Performance gains may vary based on uses of RxJava vs. Kotlin Coroutines & Flow
- 65. Here’s some lessons learned from our migration.
- 67. Basic Observable flow, flowOf Observable updated from callbacks callbackFlow / suspendCancellable Observable updated from different locations SharedFlow Observable updated from different locations that can have an initial state StateFlow Observable à Flow RxJava Observable Coroutines Flow
- 68. Backwards Compatibility Workarounds • https://github.com/Kotlin/kotlinx.coroutines/tree/master/reactive • Includes Kotlin extension functions and utilities to convert from RxJava to Coroutines & back
- 69. Handling Large Legacy Projects
- 70. Handling Large Legacy Projects
- 71. Handling Large Legacy Projects
- 72. Handling Large Legacy Projects
- 73. Improvements from migrations for our teams • Sped up feature creation • Improved app & library performance • Used Room / Lifecycle w/ Coroutines • Cleaned up app architecture patterns • Simplified unit testing
- 75. Appendix
- 76. The New York Times is Hiring! NYT Android & iOS Apps (News, Cooking, Games) Come work with us. https://www.nytco.com/careers/
- 77. Resources • https://open.nytimes.com/4-steps-to-win-advocates-and-implement-a-technical-change- b2a9b922559b • https://open.nytimes.com/threading-at-the-speed-of-light-6ae31257307a • https://medium.com/androiddevelopers/a-safer-way-to-collect-flows-from-android-uis- 23080b1f8bda • https://elizarov.medium.com/coroutine-context-and-scope-c8b255d59055 • https://medium.com/mobile-app-development-publication/kotlin-coroutine-scope-context-and-job- made-simple-5adf89fcfe94 • https://developer.android.com/kotlin/flow/stateflow-and-sharedflow#sharedflow • https://elizarov.medium.com/the-reason-to-avoid-globalscope-835337445abc • https://medium.com/androiddevelopers/coroutines-patterns-for-work-that-shouldnt-be-cancelled- e26c40f142ad • https://elizarov.medium.com/blocking-threads-suspending-coroutines-d33e11bf4761 • PetAdopt Sample App: https://github.com/laurenyew/PetAdoptSampleApp/tree/develop/android
- 78. Under the Hood Coroutines are Kotlin Extension Functions Coroutine Status Result Callbacks
- 79. Coroutine Status Result Callbacks Yield Resume Cancel Under the Hood Coroutines are Kotlin Extension Functions • State Machine (Status)
- 80. Callbacks Coroutine Status Result Callbacks Yield Resume Cancel deferred val failure (exception) Under the Hood Coroutines are Kotlin Extension Functions • State Machine (Status) • State Machine (Result) • Callbacks
- 83. CallbackFlow
- 84. CallbackFlow
- 85. CallbackFlow
- 86. LaunchIn / Collect • launchIn(scope) cleaner • Does collect behind the scenes • Use onEach{…}
- 87. Result State w/ Jetpack Compose