Dissecting Coroutines

2019 maybe be the year of Kotlin coroutines. What is a coroutine anyway? A coroutine is an instance of a state machine and a suspending function defines the state machine. What does that mean? Join me in this talk as we will explore the ins and out of coroutines. We will dive deep into channels, actors and the reactive streams modules. We’ll also look at their usage to solve common async problems in Android.

Transcript

1. Dissecting Coroutines Mohit Sarveiya @heyitsmohit
2. Dissecting Coroutines • Making API requests • Structured Concurrency • Under the hood • Context & Dispatchers • Using coroutines on Android • Channels • Shared mutable state
3. Why Coroutines? • Multiplatform support. • Asynchronous Programming with ease.
4. Making API requests
6. Login
7. Login User
8. interface AuthService { @FormUrlEncoded @POST("/login") fun login( @Field("email") email: String, @Field("password") password: String ): Call<User> }
9. sealed class ApiResponse<out T> { class Success<out T>(val data: T): ApiResponse<T>() class Error(val t: Throwable): ApiResponse<Nothing>() }
10. fun login(email: String, password: String): ApiResponse<User> { }
11. suspend fun login(email: String, password: String): ApiResponse<User> { } Suspending Function • Stop & yield without blocking calling thread • Resume execution when ready
12. suspend fun login(email: String, password: String): ApiResponse<User> { val call = apiService.login(email, password) } How do we suspend and resume with the result?
13. suspend fun <T : Any> Call<T>.await(): Response<T> { }
14. suspend fun <T> suspendCancellableCoroutine( block: (CancellableContinuation<T>) !-> Unit ): T Create suspending coroutine
15. suspend fun <T> suspendCancellableCoroutine( block: (CancellableContinuation<T>) !-> Unit ): T Use continuation interface to resume
16. interface CancellableContinuation<in T> { fun resumeWith(result: Result<T>) }
17. suspend fun <T : Any> Call<T>.await(): Response<T> { enqueue(object : Callback<T> { 
 fun onResponse(call: Call<T>, resp: Response<T>) { 
 } fun onFailure(call: Call<T>, t: Throwable) { } }) }
18. suspend fun <T : Any> Call<T>.await(): Response<T> { suspendCancellableCoroutine { cont !-> 
 enqueue(object : Callback<T> { 
 fun onResponse(c: Call<T>, resp: Response<T>) { } fun onFailure(c: Call<T>, t: Throwable) { } }) } }
19. suspend fun <T : Any> Call<T>.await(): Response<T> { suspendCancellableCoroutine { cont !-> 
 enqueue(object : Callback<T> { 
 fun onResponse(c: Call<T>, resp: Response<T>) { if (resp.isSuccessful) { cont.resume(resp) } else { cont.resumeWithException(HttpException(resp)) } } … }) } }
20. suspend fun <T : Any> Call<T>.await(): Response<T> { suspendCancellableCoroutine { cont !-> 
 enqueue(object : Callback<T> { 
 … fun onFailure(c: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) } }
21. suspend fun <T : Any> Call<T>.await(): Response<T> { return suspendCancellableCoroutine { cont !-> enqueue(object : Callback<T> { override fun onResponse(c: Call<T>, resp: Response<T>) { if (resp.isSuccessful) { cont.resume(resp) } else { cont.resumeWithException(HttpException(resp)) } } override fun onFailure(c: Call<T>, t: Throwable) { cont.resumeWithException(t) } }) } }
23. suspend fun login(email: String, password: String): ApiResponse<User> { return apiService.login(email, password).await() }
24. suspend fun login(email: String, password: String): ApiResponse<User> { return apiService.login(email, password).await() } How do I use this?
25. fun main() { login(email, password) }
26. fun main() { login(email, password) } Can only suspending functions from other suspending functions
27. GlobalScope.launch { val response = login(email, password) when(response) { is ApiResponse.Success !-> { } is ApiResponse.Error !-> { } } }
28. GlobalScope.launch { val response = login(email, password) when(response) { is ApiResponse.Success !-> { } is ApiResponse.Error !-> { } } } Scope to lifecycle of app
29. val job: Job = GlobalScope.launch { val response = login(email, password) when (response) { is ApiResponse.Success !-> { } is ApiResponse.Error !-> { } } }
30. interface Job { val isActive: Boolean val isCompleted: Boolean val isCancelled: Boolean fun cancel() }
31. val job: Job = GlobalScope.launch { val response = login(email, password) when (response) { is ApiResponse.Success !-> { } is ApiResponse.Error !-> { } } } job.cancel()
32. Login User
33. User Id Token
34. fun authenticate(email: String, password: String, callback: Callback) { login(email, password) { user !-> token(user.id) { token !-> storeToken(token) { callback.success() } } } } Chained callbacks
35. fun authenticate(email: String, password: String) { GlobalScope.launch { val user = login(email, password) val token = getToken(user.id) storeToken(token) } }
36. fun authenticate(email: String, password: String) { GlobalScope.launch { val user = login(email, password) val token = getToken(user.id) storeToken(token) } } How do I return the result to the caller?
37. public fun <T> CoroutineScope.async( block: suspend CoroutineScope.() !-> T ): Deferred<T> Kotlin Coroutine’s future type
38. fun authenticate(email: String, password: String): Deferred<Boolean> = GlobalScope.async { val user = login(email, password) val token = getToken(user.id) storeToken(token) }
39. Structured Concurrency
40. Post Media Item 1 Media Item 2 Media Item 3 Media Item 4
41. fun showPostDetails(posts: List<Post>) { }
42. fun showPostDetails(posts: List<Post>) { for (post in posts) { GlobalScope.launch { } } }
43. fun showPostDetails(posts: List<Post>) { for (post in posts) { GlobalScope.launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } }
44. fun showPostDetails(posts: List<Post>) { for (post in posts) { GlobalScope.launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } } Request 1 Request 2 Request 3 Request 4
45. fun showPostDetails(posts: List<Post>) { for (post in posts) { GlobalScope.launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } } Request 1 Request 2 Request 3 Request 4
46. suspend fun showPostDetails(posts: List<Post>) { for (post in posts) { GlobalScope.launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } } Suspending method
47. suspend fun showPostDetails(posts: List<Post>) { coroutineScope { for (post in posts) { GlobalScope.launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } } } Create a scope
48. suspend fun showPostDetails(posts: List<Post>) { coroutineScope { for (post in posts) { launch { val mediaItem = loadMediaItems(post.id) showMediaItem(mediaItem) } } } } Request 1 Request 2 Request 3 Request 4 Cancel all the coroutines
49. Under the hood
50. GlobalScope.launch { val user = login(email, password) val token = getToken(user.id) storeToken(token) }
51. login(Ljava/lang/String; Ljava/lang/String; Lkotlin/coroutines/Continuation;) login(email, password) Bytecode Suspending function
52. interface Continuation<in T> { val context: CoroutineContext fun resumeWith(result: Result<T>) }
53. GlobalScope.launch { val user = login(email, password) val token = getToken(user.id) storeToken(token) } Create an instance of state machine
54. Continuation create(…) { int label; Object invokeSuspend() { switch(this.label) { case 0: … case 1: … case 2: … } } } login(email, password) getToken(user.id) storeToken(token)
55. class CancellableContinuationImpl<in T> : CancellableContinuation<T> { val _state = atomic<Any?>(Active) 
 fun resumeWith(result: Result<T>) 
 fun invokeSuspend() 
 fun cancel(cause: Throwable?): Boolean }
56. switch(this.label) { case 0: CoroutineScope var2 = this.p$; var6 = MainActivity.this.getEmail(); String var10001 = MainActivity.this.getPassword(); this.label = 1; var10000 = MainActivityKt.login(var6, var10001, this); break; Save suspension point
57. switch(this.label) { case 0: CoroutineScope var2 = this.p$; var6 = MainActivity.this.getEmail(); String var10001 = MainActivity.this.getPassword(); this.label = 1; var10000 = MainActivityKt.login(var6, var10001, this); break; Pass in instance of state machine
58. GlobalScope.launch { val user = login(email, password) val token = getToken(user.id) storeToken(token) }
59. Context & Dispatchers
60. Dispatcher Schedules coroutines to run on a thread pool
61. Dispatchers • IO • Main • Unconfined • Default
62. GlobalScope.launch { println(Thread.currentThread().name) } DefaultDispatcher-worker-1 DefaultDispatcher
63. Dispatchers.IO • Designed for I/O tasks • Uses about 64 threads.
64. GlobalScope.launch(context = Dispatchers.IO) { }
65. fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() !-> Unit ):
66. fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() !-> Unit ): Indexed set
67. interface CoroutineContext { interface Key<E : Element> interface Element : CoroutineContext … }
68. Job Element IO Unconfined Main Default
69. interface CoroutineContext { fun <E : Element> get(key: Key<E>): E? fun plus(context: CoroutineContext): CoroutineContext … }
70. GlobalScope.launch { println(this.coroutineContext[Job]) } StandaloneCoroutine{Active}
71. GlobalScope.launch { println(Thread.currentThread().name) withContext(newSingleThreadContext("Single Thread")) { println(Thread.currentThread().name) } }
72. GlobalScope.launch { println(Thread.currentThread().name) withContext(newSingleThreadContext("Single Thread")) { println(Thread.currentThread().name) } } DefaultDispatcher Single Thread
73. Using Coroutines on Android
74. kotlinx-coroutines-core -android -rx jars: 774 KB R8: 99KB
75. Password Email Password LOG IN
76. Activity 
 
 ViewModel LiveData Repository
77. class LoginRepository(val dispatcher: CoroutineDispatcher, val apiService: ApiService) { suspend fun login(email: String, password: String): ApiResponse<User> = withContext(dispatcher) { try { val response = apiService.login(email, password).await() ApiResponse.Success(response.body()) } catch (e: HttpException) { ApiResponse.Error(e) } } }
78. class LoginViewModel(val loginRepository: LoginRepository): ViewModel() { val viewModelJob = Job() val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob) }
79. public fun CoroutineScope(context: CoroutineContext): CoroutineScope = ContextScope(if (context[Job] !!= null) context else context + Job())
80. public interface CoroutineContext { operator fun plus(context: CoroutineContext): CoroutineContext }
81. class LoginViewModel(val loginRepository: LoginRepository): ViewModel() { val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob) fun onLoginClicked(email: String, password: String) { uiScope.launch { val apiResponse = loginRepository.login(email, password) } } … }
82. class LoginViewModel(val loginRepository: LoginRepository): ViewModel() { val uiScope = CoroutineScope(Dispatchers.Main + viewModelJob) fun onLoginClicked(email: String, password: String) { uiScope.launch { val apiResponse = loginRepository.login(email, password) when(apiResponse) { is ApiResponse.Success !-> { showActivity() } is ApiResponse.Error !-> { showError() } } } } }
83. class LoginViewModel(val loginRepository: LoginRepository): ViewModel() { val viewModelJob = Job() … override fun onCleared() { super.onCleared() viewModelJob.cancel() } }
85. val ViewModel.viewModelScope: CoroutineScope get() { val scope: CoroutineScope? = this.getTag(JOB_KEY) if (scope !!= null) { return scope } return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope(Job() + Dispatchers.Main)) }
86. class LoginViewModel(val loginRepository: LoginRepository): ViewModel() { fun onLoginClicked(email: String, password: String) { viewModelScope.launch { val apiResponse = loginRepository.login(email, password) } } }
87. Channels
88. Channel Send Receive
89. 1 4 9 16 25 Producer
90. val channel = Channel<Int>() launch { for (x in 1!..5) channel.send(x * x) } 1 4 9 16 25
91. val channel = Channel<Int>() launch { for (x in 1!..5) channel.send(x * x) } repeat(5) { println(channel.receive()) } 1 4 9 16 25 Producer Consumer
92. 1 2 3 4 5 Infinite Stream
93. 1 2 3 4 5 fun CoroutineScope.produceNumbers() = produce<Int> { var x = 1 while (true) send(x!++) }
94. 1 2 3 4 5 1 4 9 16 25 Transform
95. fun CoroutineScope.square(numbers: ReceiveChannel<Int>): ReceiveChannel<Int> = produce { for (x in numbers) send(x * x) } 1 4 9 16 25 Consuming another channel
96. val numbers = produceNumbers() val squares = square(numbers) for (i in 1!..5) println(squares.receive()) coroutineContext.cancelChildren() Composing channels
97. val numbers = produceNumbers() val squares = square(numbers) for (i in 1!..5) println(squares.receive()) for (i in 1!..5) println(squares.receive()) coroutineContext.cancelChildren() Cannot consume channel again.
98. fun CoroutineScope.square(numbers: ReceiveChannel<Int>): ReceiveChannel<Int> = publish { for (x in numbers) send(x * x) } Use cold reactive publisher
99. val numbers = produceNumbers() val squares = square(numbers) for (i in 1!..5) println(squares.receive()) for (i in 1!..5) println(squares.receive()) coroutineContext.cancelChildren()
101. Shared Mutable State
102. Coroutine 1 Coroutine 2 Coroutine 3 Coroutine 100 … State
103. Coroutine 1 Coroutine 2 Coroutine 3 Coroutine 100 … State
104. var counter = 0 State
105. var counter = 0 suspend fun CoroutineScope.massiveRun() { }
106. var counter = 0 suspend fun CoroutineScope.massiveRun(action: suspend () !-> Unit) { }
107. var counter = 0 suspend fun CoroutineScope.massiveRun(action: suspend () !-> Unit) { val jobs = List(100) { launch { } } } Launch 100 coroutines!
108. var counter = 0 suspend fun CoroutineScope.massiveRun(action: suspend () !-> Unit) { val jobs = List(100) { launch { repeat(1000) { action() } } } } Mutate counter 1000 times!
109. var counter = 0 GlobalScope.massiveRun { counter!++ } println(counter)
110. var counter = 0 GlobalScope.massiveRun { counter!++ } println(counter) 71906
111. var counter = 0 GlobalScope.massiveRun { counter!++ } println(counter) 56467
112. Shared Mutable State • Thread safe data structure • Mutex • Actors
113. var counter = AtomicInteger() GlobalScope.massiveRun { counter!++ } println(counter)
114. var counter = AtomicInteger() GlobalScope.massiveRun { counter.incrementAndGet() } println(counter) 100,000
115. Shared Mutable State • Thread safe data structure • Mutex • Actors
116. public interface Mutex { public val isLocked: Boolean public suspend fun lock(owner: Any? = null) public fun unlock(owner: Any? = null) … }
117. var mutext = Mutex() var counter = 0 GlobalScope.massiveRun { mutext.lock() try { counter!++ } finally { mutext.unlock() } } Critical Section
118. public suspend inline fun <T> Mutex.withLock(owner: Any? = null, action: () !-> T ): T { lock(owner) try { return action() } finally { unlock(owner) } }
119. var mutext = Mutex() var counter = 0 GlobalScope.massiveRun { mutext.withLock { counter!++ } }
120. Shared Mutable State • Thread safe data structure • Mutex • Actors
121. State Actor
122. State Actor Channel
123. State Actor Channel Coroutine
124. State Actor Channel Coroutine Message
125. State Actor Channel Coroutine Message
126. sealed class CounterEvents object IncCounter : CounterEvents() Channel Coroutine IncCounter
127. sealed class CounterEvents object IncCounter : CounterEvents() class GetCounter( val response: CompletableDeferred<Int> ) : CounterEvents() Channel Coroutine GetCounter
128. public fun <E> CoroutineScope.actor( block: suspend ActorScope<E>.() !-> Unit ): SendChannel<E> { … }
129. public fun <E> CoroutineScope.actor( block: suspend ActorScope<E>.() !-> Unit ): SendChannel<E> { … } ! Experimental
130. fun CoroutineScope.counterActor() = actor<CounterEvents> { var counter = 0 } State
131. fun CoroutineScope.counterActor() = actor<CounterEvents> { var counter = 0 for (msg in channel) { when (msg) { is IncCounter !-> counter!++ is GetCounter !-> msg.response.complete(counter) } } } Process Events
132. val actor = counterActor() GlobalScope.massiveRun { actor.send(IncCounter) } counter.close() Send message to increment counter
133. val actor = counterActor() GlobalScope.massiveRun { actor.send(IncCounter) } val response = CompletableDeferred<Int>() counter.send(GetCounter(response)) println(response.await()) counter.close() Send Message 
 to get value
134. Looking ahead
137. Thank you! twitter.com/heyitsmohit