Introduction to Kotlin Coroutines

Introduction to kotlin coroutines, talk given at Berlin Android Monthly meetup @Berlindroid

Transcript

1. Introduction to Kotlin Coroutines by Mayowa Adegeye (@mayojava) @Belindroid
2. • AsyncTask
3. • AsyncTask • Service/IntentService
4. • AsyncTask • Service/IntentService • Loaders & Handlers
5. • AsyncTask • Service/IntentService • Loaders & Handlers • Callbacks
6. • AsyncTask • Service/IntentService • Loaders & Handlers • Callbacks • RxJava
7. fun login(username: String, password: String): User
8. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders>
9. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders> fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) }
10. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders> fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) } I/O calls
11. fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders> fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) } UI thread
12. Callback fun fetchUserOrders(username: String, password: String) { login(username, password) { user -> getOrders(user.userId) { orders -> showUserOrders(orders) } } }
13. RxJava fun fetchUserOrders(username: String, password: String) { login(username, password) .flatMap { user → getOrders(user.userId) } .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.main()) .subscribe({orders -> showUserOrders(orders)}) }
14. Is it possible to write async code in a sequential manner without getting lost in the implementation details ?
16. with COROUTINES
17. What is a coroutine
18. What is a coroutine • A lightweight thread that can run a computation without blocking.
19. What is a coroutine • A lightweight thread that can run a computation without blocking. • It can be suspended and resumed at a later time.
20. What is a coroutine • A lightweight thread that can run a computation without blocking. • It can be suspended and resumed at a later time. • Suspension points are defined by the programmer.
21. Key Coroutine Concepts
22. Key Coroutine Concepts • Suspending functions
23. Key Coroutine Concepts • Suspending functions • Coroutine Dispatchers
24. Key Coroutine Concepts • Suspending functions • Coroutine Dispatchers • Coroutine Builders
25. Suspending function • A function that can suspend the execution of a coroutine
26. Suspending function • A function that can suspend the execution of a coroutine • It can be started, paused and resumed at a later time
29. Suspending function...contd • They can only be called within a coroutine or from another suspending function
30. Suspending function • They can only be called within a coroutine or from another suspending function • They can take parameters and have return types
31. Syntax suspend fun doHeavyComputation(param: Int): Int { //heavy computation body }
32. fun doHeavyComputation(param: Int,callback:Continuation<Int>)
33. fun doHeavyComputation(param: Int,callback:Continuation<Int>) interface Continuation<in T> { public val context: CoroutineContext public fun resumeWith(result: Result<T>) } fun<T> Continuation<T>.resume(value: T) { } fun<T> Continuation<T>.resumeWithException(exception: Throwable)
34. Coroutine Dispatchers
35. Coroutine Dispatchers • CoroutineContext Element that determines the thread a coroutine runs on.
36. Coroutine Dispatchers • CoroutineContext Element that determines the thread a coroutine runs on. • It can confine a coroutine to a specific thread, a threadpool or let it run unconfined.
37. Kotlinx.coroutines dispatchers • Dispatchers.DEFAULT
38. Kotlinx.coroutines dispatchers • Dispatchers.DEFAULT • Dispatchers.IO
39. Kotlinx.coroutines dispatchers • Dispatchers.DEFAULT • Dispatchers.IO • Dispatchers.UNCONFINED
40. Kotlinx.coroutines dispatchers • Dispatchers.DEFAULT • Dispatchers.IO • Dispatchers.UNCONFINED • Dispatchers.MAIN
41. Kotlinx.coroutines dispatchers • Dispatchers.DEFAULT • Dispatchers.IO • Dispatchers.UNCONFINED • Dispatchers.MAIN • newFixedThreadPoolContext & newSingleThreadContext
42. CoroutineContext Element • Job
43. CoroutineContext Element • Job • ContinuationInterceptor
44. CoroutineContext Element • Job • ContinuationInterceptor • CoroutineExceptionHandler
45. CoroutineContext Element • Job • ContinuationInterceptor • CoroutineExceptionHandler • CoroutineName
46. Coroutine Builders
47. Coroutine Builders Acts as the bridge that allows us to call suspending functions from our code.
48. Coroutine Builders Acts as the bridge that allows us to call suspending functions from our code. • launch - fire and forget
49. Coroutine Builders Acts as the bridge that allows us to call suspending functions from our code. • launch - fire and forget • async - returns a Deferred<T>
50. launch fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, Start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit ): Job
51. async fun <T> CoroutineScope.async( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T ): Deferred<T>
52. Async • You need to call await() on the returned Deferred<T> to get the actual result.
53. Async • You need to call await() on the returned Deferred<T> to get the actual result. • async...await can be used to run several tasks in parallel.
54. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 }
55. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 } suspend fun secondValue(): Int { delay(300) //delays for 300ms return 20 }
56. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 } suspend fun secondValue(): Int { delay(300) //delays for 300ms return 20 } fun main() = runBlocking { val time = measureTimeMillis { val first = async { firstValue() } val second = async { secondValue() } val sum = first.await() + second.await() } println(time) }
57. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 } suspend fun secondValue(): Int { delay(300) //delays for 300ms return 20 } fun main() = runBlocking { val time = measureTimeMillis { val first = async { firstValue() } val second = async { secondValue() } val sum = first.await() + second.await() } println(time) }
58. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 } suspend fun secondValue(): Int { delay(300) //delays for 300ms return 20 } fun main() = runBlocking { val time = measureTimeMillis { val first = async { firstValue() } val second = async { secondValue() } val sum = first.await() + second.await() } println(time) }
59. suspend fun firstValue(): Int { delay(500) //delays for 500ms return 10 } suspend fun secondValue(): Int { delay(300) //delays for 300ms return 20 } fun main() = runBlocking { val time = measureTimeMillis { val first = async { firstValue() } val second = async { secondValue() } val sum = first.await() + second.await() } println(time) //prints 518 }
60. withContext Can be used to run a block of code that returns in a value in another context.
61. withContext Can be used to run a block of code that returns in a value in another context. It suspends until completion and returns the result
62. withContext public suspend fun <T> withContext( context: CoroutineContext, block: suspend CoroutineScope.() -> T ): T
63. Get user orders revisited fun login(username: String, password: String): User fun getOrders(userId: String): List<Orders> fun fetchUserOrders() { val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) }
64. Get user orders revisited suspend fun login(username: String, password: String): User { return withContext(Dispatcher.IO) { //returns User } }
65. Get user orders revisited suspend fun login(username: String, password: String): User { return withContext(Dispatcher.IO) { //returns User } } suspend fun getOrders(userId: String): List<Orders> { return withContext(Dispatchers.IO) { //return list of orders } }
66. Get user orders revisited fun fetchUserOrders() = GlobalScope.launch(Dispatchers.MAIN){ val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) }
67. Get user orders revisited fun fetchUserOrders() = GlobalScope.launch(Dispatchers.MAIN){ val user = login(username, password) //first suspension point val orders = getOrders(user.userId) showUserOrders(orders) }
68. Get user orders revisited fun fetchUserOrders() = GlobalScope.launch(Dispatchers.MAIN){ val user = login(username, password) val orders = getOrders(user.userId) //second suspension point showUserOrders(orders) }
69. Get user orders revisited fun fetchUserOrders() = GlobalScope.launch(Dispatchers.MAIN){ val user = login(username, password) val orders = getOrders(user.userId) showUserOrders(orders) } back on main thread and can update the UI
70. Structured concurrency • All coroutine builders are extension function of CoroutineScope
71. Structured concurrency • All coroutine builders are extension function of CoroutineScope • We need to be able to keep track of all coroutines launched
72. Structured concurrency • All coroutine builders are extension function of CoroutineScope • We need to be able to keep track of all coroutines launched • CoroutineScope should be implemented by an object with a lifeycle i.e Activity, Fragment, ViewModel
73. class MainActivity: AppCompatActivity() { private fun loadData() { } }
74. class MainActivity: AppCompatActivity(), CoroutineScope { private fun loadData() { } }
75. class MainActivity: AppCompatActivity(), CoroutineScope { override val coroutineContext: CoroutineContext get() = Dispatchers.Main private fun loadData() { } }
76. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.Main private fun loadData() { } }
77. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.Main override fun onCreate(savedInstanceState: Bundle?) { job = Job() } private fun loadData() { } }
78. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.Main override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
79. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
80. class MainActivity: AppCompatActivity(), CoroutineScope { private lateint var job override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job override fun onCreate(savedInstanceState: Bundle?) { job = Job() } override fun onDestroy() { job.cancel() } }
81. Conventions • Functions declared as extension function on CoroutineScope should return immediately and executes its task concurrently with the rest of the program.
82. Conventions • Functions declared as extension function on CoroutineScope should return immediately and executes its task concurrently with the rest of the program. • Suspending functions should do its task separately in another context and return to caller when done. It should not block the caller.
83. Conventions • Suspending functions should do its task separately in another context and return to caller when done. It should not block the caller. • Functions should not be both suspending and an extension function on coroutine scope.
84. Don’t do this suspend fun CoroutineScope.launchBackgroundWork()
85. Do this fun CoroutineScope.launchBackgroundWork() = launch { }
86. Do this fun CoroutineScope.launchBackgroundWork() = launch { } suspend fun doIOWork() = withContext(Dispatchers.IO) { }
87. Exception Handling • Wrap suspend functions or deferred.await() in a try..catch block
88. Exception Handling • Wrap suspend functions or deferred.await() in a try..catch block • Launch coroutine builder propagates exceptions as an unhandled exception, while async exposes the exception to the user to consume.
89. val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() } val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() }
90. val job = GlobalScope.launch { println("Throwing exception from launch") throw IndexOutOfBoundsException() //exception will be printed to console } val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() // Nothing is printed, relying on user to call await }
91. val deferred = GlobalScope.async { println("Throwing exception from async") throw ArithmeticException() // Nothing is printed, relying on user to call await } try { deferred.await() println("Unreached") } catch (e: ArithmeticException) { println("Caught ArithmeticException") //printed to the console }
92. use CoroutineExceptionHandler context element as a generic handler for all uncaught exceptions.
93. val exceptionHandler = CoroutineExceptionHandler { _, exception -> println(“Caught: $exception") }
94. val exceptionHandler = CoroutineExceptionHandler { _, exception -> println(“Caught: $exception") } val job = GlobalScope.launch(exceptionHandler) { }
95. val exceptionHandler = CoroutineExceptionHandler { _, exception -> println(“Caught: $exception") } val job = GlobalScope.launch(exceptionHandler) { throw IOException(“error occurred”) } //console output: Caught: java.io.IOException: error occurred
96. CoroutineExceptionHandler is only invoked on exceptions that are not expected to be handled by the user
97. val exceptionHandler = CoroutineExceptionHandler { _, exception -> println(“Caught: $exception") } val job = GlobalScope.async(exceptionHandler) { throw IndexOutOfBoundsException(“error occurred”) } //exception will be swallowed and nothing printed to the console
98. Testing Make your viewmodels, use cases or repositories explicitly take a Dispatcher and provide a replacement in your test.
99. data class DispatcherProvider( val io: CoroutineDispatcher, val computation: CoroutineDispatcher, val main: CoroutineDispatcher )
100. data class DispatcherProvider( val io: CoroutineDispatcher, val computation: CoroutineDispatcher, val main: CoroutineDispatcher ) @Provides @Singleton fun providesDispatchersProvider() = DispatcherProvider( io = Dispatchers.IO, computation = Dispatchers.Default, main = Dispatchers.Main )
101. class FetchMoviesUseCase(private val moviesApi: MoviesApi, private val dispatcherProvider: DispatcherProvider) { suspend fun movies(): List<Movies> { return withContext(dispatcherProvider.io) { moviesApi.getMovies() } } }
102. use Unconfined Dispatcher in test @Provides @Singleton fun providesTestDispatchers() = DispatcherProvider( io = Dispatchers.Unconfined, computation = Dispatchers.Unconfined, main = Dispatchers.Unconfined )
103. TestCoroutineContext • use TestCoroutineContext if you deal with delays and timeout in your test.
104. TestCoroutineContext • use TestCoroutineContext if you deal with delays and timeout in your test. • Similar to TestScheduler in RxJava
105. TestCoroutineContext • use TestCoroutineContext if you deal with delays and timeout in your test. • Similar to TestScheduler in RxJava • advanceTimeBy
106. TestCoroutineContext • use TestCoroutineContext if you deal with delays and timeout in your test. • Similar to TestScheduler in RxJava • advanceTimeBy • advanceTimeTo
107. TestCoroutineContext • use TestCoroutineContext if you deal with delays and timeout in your test. • Similar to TestScheduler in RxJava • advanceTimeBy • advanceTimeTo • triggerActions
108. Topics not covered • Channels • Coroutines and RxJava interoperability
109. Further Reading Google Coroutines code lab Kotlin Coroutines guide Structured Concurrency by Roman Elizarov