Coroutines in Kotlin v3: In-depth review

Slides from my talk at UA Mobile 2017, 2017-11-25
Video: https://www.youtube.com/watch?v=tql9fmWX_oc

Modern programming cannot be imagined without long-running operations such as CPU-intensive computations or blocking IO running in the background. Unfortunately, having too many active threads is very expensive and kills performance, but there's a solution - coroutines. They provide a way to avoid blocking a thread and replace it with a cheaper and more controllable operation: suspension of a coroutine.

I'll talk about generators/yield, async/await, channels, composable/delimited continuations, and its usage; consider available APIs and make the overview of standard kotlinx.coroutines library.

Transcript

1. Coroutines in Kotlin: In-depth review Dmytro Zaitsev Team Leader @ Lóhika
2. Blocking VS Non-blocking
4. v1: Sequential (Direct style) fun postItem(item: Item) {
 val token = prepareToken() / / 1
 val post = submitPost(token, item) / / 2
 processPost(post) / / 3
 }
5. v2: Callbacks (Continuation-Passing style) fun postItem(item: Item) {
 prepareTokenAsync { token -> / / 1
 submitPostAsync(token, item) { post -> / / 2
 processPost(post) / / 3
 }
 }
 } Continuation
6. v2: Callbacks (Continuation-Passing style) fun postItem(item: Item) {
 prepareTokenAsync { token -> / / 1
 submitPostAsync(token, item) { post -> / / 2
 processPost(post) / / 3
 }
 }
 } Callback hell
7. v3: Rx/Futures/Promises fun postItem(item: Item) {
 observeToken()
 .concatMap { token -> observePost(token, item) }
 .subscribe { post -> processPost(post) }
 }
8. v4: Coroutines Direct Style suspend fun postItem(item: Item) {
 val token = prepareToken() / / 1
 val post = submitPost(token, item) / / 2
 processPost(post) / / 3
 }
9. v4: Coroutines Direct Style suspend fun postItem(item: Item) {
 val token = prepareToken() / / 1
 val post = submitPost(token, item) / / 2
 processPost(post) / / 3
 }
10. v4: Coroutines Direct Style suspend fun postItem(item: Item) {
 val token = prepareToken() / / 1
 val post = submitPost(token, item) / / 2
 processPost(post) / / 3
 }
11. Profit: try/catch, loops, std-lib suspend fun postItems(items: List<Item>) { try { val token = prepareToken() items.forEach { item -> val post = submitPost(token, item) processPost(post) } } catch (e: BadTokenException) { /*…*/ } }
12. suspend fun computation that can be suspended
13. Experimental status Since Kotlin 1.1 -Xcoroutines=enable kotlin.coroutines.experimental -> kotlin.coroutines (1.3) Experimental != unstable Can and should be used in production
14. Experimental status New style of programming The design is not final and expected to change JetBrains still collects information and feedbacks Backwards compatibility guaranteed
15. Terminology coroutine suspending function suspending lambda suspending function type coroutine builder suspension point continuation
16. Terminology coroutine suspending function suspending lambda suspending function type coroutine builder suspension point continuation
17. A coroutine is… an instance of suspendable computation similar to a daemon thread, but very light-weight similar to a future or promise
18. Why coroutines? threads are expensive to keep and switch your code is single threaded you’ve got lots of mutable states
19. Patterns • generators/yield: C#, Python, Scala • async/await: C#, ECMAScript, Dart • channels, select: Go • actors: Scala
20. Standard API • Language support (`suspend` keyword) • low-level basic API (stdlib: kotlin.coroutines) • high-level APIs that can be used in user code
21. Low-level API (kotlin.coroutines) • kotlin.coroutines.experimental • create/start/suspendCoroutine() • Continuation interface • @RestrictSuspension annotation • kotlin.coroutines.experimental.intrinsics • suspendCoroutineOrReturn()
22. How does it work under the hood?
23. Continuation interface Continuation<in T> {
 val context: CoroutineContext
 fun resume(value: T)
 fun resumeWithException(exception: Throwable)
 }
24. Continuation / / Kotlin suspend fun submitPost( token: Token, item: Item): Post {…} / / Java/JVM Object submitPost( Token token, Item item, Continuation<Post> cont) {…} compiler magic
25. Continuations suspend fun postItem(item: Item) {
 val token = prepareToken()
 val post = submitPost(token, item)
 processPost(post)
 } Initial continuation
26. Continuations suspend fun postItem(item: Item) {
 val token = prepareToken()
 val post = submitPost(token, item)
 processPost(post)
 } Continuation
27. Continuations suspend fun postItem(item: Item) {
 val token = prepareToken()
 val post = submitPost(token, item)
 processPost(post)
 } Continuation
28. Labels suspend fun postItem(item: Item) { / / LABEL 0
 val token = prepareToken() / / LABEL 1
 val post = submitPost(token, item) / / LABEL 2
 processPost(post)
 }
29. Labels suspend fun postItem(item: Item) { switch(label) { case 0: val token = prepareToken() case 1:
 val post = submitPost(token, item) case 2:
 processPost(post) }
 }
30. State suspend fun postItem(item: Item) { val stateMachine = object: CoroutineImpl {…} switch(stateMachine.label) { case 0: val token = prepareToken() case 1:
 val post = submitPost(token, item) case 2:
 processPost(post) }
 }
31. CPS Transform fun postItem(item: Item, cont: Continuation) { val stateMachine = object: CoroutineImpl {…} switch(stateMachine.label) { case 0: val token = prepareToken(stateMachine) case 1:
 val post = submitPost(token, item, stateMachine) case 2:
 processPost(post) }
 }
32. Save state fun postItem(item: Item, cont: Continuation) { val stateMachine = object: CoroutineImpl {…} switch(stateMachine.label) { case 0: stateMachine.item = item stateMachine.label = 1 prepareToken(stateMachine) case 1:
 … }
 }
33. Callback fun postItem(item: Item, cont: Continuation) { val stateMachine = cont as? ThisSM ?: object: ThisSM { fun resume(…) { postItem(null, this) } } switch(stateMachine.label) { case 0: …. }
 }
34. Restore state and continue fun postItem(item: Item, cont: Continuation) { … case 0: stateMachine.item = item stateMachine.label = 1 prepareToken(stateMachine) case 1: val item = stateMachine.item val token = stateMachine.result stateMachine.label = 2
 submitPost(token, item, stateMachine) case 2:
 …
35. How to create custom coroutines?
36. Await for a Single suspend fun <T> Single<T>.await(): T = TODO()
37. Suspend a coroutine suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> / / … }
38. Subscribe suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> subscribe(object : SingleObserver<T> { override fun onSuccess(t: T) { TODO() } override fun onError(error: Throwable) { TODO() } override fun onSubscribe(d: Disposable) { TODO() } }) }
39. Return a result, if successful suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> subscribe(object : SingleObserver<T> { override fun onSuccess(t: T) { cont.resume(t) } override fun onError(error: Throwable) { TODO() } override fun onSubscribe(d: Disposable) { TODO() } }) }
40. Or resume with exception suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> subscribe(object : SingleObserver<T> { override fun onSuccess(t: T) { cont.resume(t) } override fun onError(error: Throwable) { cont.resumeWithException(error) } override fun onSubscribe(d: Disposable) { TODO() } }) }
41. Don’t forget to dispose suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> subscribe(object : SingleObserver<T> { override fun onSuccess(t: T) { cont.resume(t) } override fun onError(error: Throwable) { cont.resumeWithException(error) } override fun onSubscribe(d: Disposable) { cont.invokeOnCompletion { d.dispose() } } }) }
42. And this is it suspend fun <T> Single<T>.await(): T = suspendCancellableCoroutine { cont -> subscribe(object : SingleObserver<T> { override fun onSuccess(t: T) { cont.resume(t) } override fun onError(error: Throwable) { cont.resumeWithException(error) } override fun onSubscribe(d: Disposable) { cont.invokeOnCompletion { d.dispose() } } }) }
43. kotlinx.coroutines Core integration Guava JDK 8 NIO Quasar reactive Reactor RxJava 1.x Reactive Streams RxJava 2.x UI Android JavaFX Swing
44. async promise returned (Deferred + await)
45. async/await / / C# way async Task ProcessImage(String url)
 {
 var image = await LoadImage(url);
 imageCache.Add(image);
 } / / Kotlin way suspend fun processImage(url: String) {
 val image = loadImageAsync(url).await()
 imageCache.add(image)
 }
46. Not idiomatic way fun loadImageAsync(url: String): Deferred<Image> = async { TODO() } suspend fun processImage(url: String) { val image = loadImageAsync(url).await() imageCache.add(image) } Don’t define async functions in the first place
47. Idiomatic way suspend fun loadImage(url: String): Image = TODO() suspend fun processImage(url: String) { val image = async { loadImage(url) }.await() imageCache.add(image) } Keep concurrency explicit
48. Generators API in kotlin.coroutines kotlin.coroutines.experimental buildIterator() buildSequence()
49. buildSequence {
 print(“Start: ")
 var prev = 1; var cur = 1
 while (true) { print(“Next")
 yield(prev) / / suspension point val next = prev + cur
 prev = cur; cur = next
 }
 print("End") / / unreachable code
 }.take(6).forEach { print(" $it ") }
 / / Output: Start 1 Next 1 Next 2 Next 3 Next 5 Next 8
50. buildSequence {
 print(“Start: ")
 var prev = 1; var cur = 1
 while (true) { print(“Next")
 yield(prev) / / suspension point val next = prev + cur
 prev = cur; cur = next
 }
 print("End") / / unreachable code
 }.take(6).forEach { print(" $it ") }
 / / Output: Start 1 Next 1 Next 2 Next 3 Next 5 Next 8
51. buildSequence {
 print(“Start: ")
 var prev = 1; var cur = 1
 while (true) { print(“Next")
 yield(prev) / / suspension point val next = prev + cur
 prev = cur; cur = next
 }
 print("End") / / unreachable code
 }.take(6).forEach { print(" $it ") }
 / / Output: Start 1 Next 1 Next 2 Next 3 Next 5 Next 8
52. buildSequence {
 print(“Start: ")
 var prev = 1; var cur = 1
 while (true) { print(“Next")
 yield(prev) / / suspension point val next = prev + cur
 prev = cur; cur = next
 }
 print("End") / / unreachable code
 }.take(6).forEach { print(" $it ") }
 / / Output: Start 1 Next 1 Next 2 Next 3 Next 5 Next 8
53. buildSequence {
 print(“Start: ")
 var prev = 1; var cur = 1
 while (true) { print(“Next")
 yield(prev) / / suspension point val next = prev + cur
 prev = cur; cur = next
 }
 print("End") / / unreachable code
 }.take(6).forEach { print(" $it ") }
 / / Output: Start 1 Next 1 Next 2 Next 3 Next 5 Next 8
54. launch fire and forget (Job)
55. run, runBlocking for main functions and tests
56. delay like Thread.sleep(), but non-blocking
57. Channel transfers values between coroutines
58. produce produces a stream of values by sending them to a channel (ProducerJob)
59. actor deals with it’s mailbox (ActorJob)
60. select waits for the result of multiple suspending functions
61. Job lifecycle New Active Cancelling Completed Cancelled
62. Job states State isActive isCompleted isCancelled New - - - Active ✔ - - Completed - ✔ - Cancelling - - ✔ Cancelled - ✔ ✔
63. val deferred = async(CommonPool) {
 throw SomeException("I'm thrown inside a coroutine")
 }
 try {
 deferred.await() / / re-throws
 } catch (e: SomeException) {
 log(e.message)
 } Exception handling
64. Memory leaks
65. WeakReference “life hack” suspend operator fun <T> WeakReference<T>.invoke(): T = suspendCoroutineOrReturn { get() ?: throw CancellationException() } val activityRef = WeakReference(this)
 launch(CommonPool) {
 activityRef().expensiveComputation()
 }
66. Demo
67. A lot more left… Coroutine dispatchers Cancellation Mutable state and concurrency UI programming Reactive streams
68. Links Andrey Breslav FAQ:
 https:/ /discuss.kotlinlang.org/t/experimental-status-of-coroutines-in-1-1-and- related-compatibility-concerns/2236 Design document (KEEP):
 https:/ /github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines- informal.md Full kotlinx.coroutines API:
 http:/ /kotlin.github.io/kotlinx.coroutines Coroutines guide by Roman ELizarov:
 https:/ /github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md
69. We are hiring!
70. Thank you! @DmitriyZaitsev