Kotlin Coroutines: Beyond async-await

Kotlin coroutines support the familiar async/await style, as well as channel and goroutine styles. Learning from the predecessors, designers of the language managed to accomplish this with only one reserved keyword: suspend.

Coroutines were invented at the dawn of programming languages, but were quickly forgotten when threads and other fashionable techniques were popularized. They are making a major comeback as many mainstream languages have introduced support for coroutines and similar mechanisms: async/await, channels, goroutines. Kotlin language designers figured out a way to emulate many of those patterns by pushing the details to the library functions and reserving only one keyword: suspend.

Transcript

1. Kotlin Coroutines Beyond async/await Bolot Kerimbaev
2. Problem • We want async • Async is hard
3. Problem val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2) displayImage(result)
4. Solutions • AsyncTask • Callback • Observable, Reactive • Future, Promise
5. Callback loadImageCallback(url1) { image1 -> .loadImageCallback(url2) { image2 -> combineImages(image1, image2) { displayImage(result) } } }
6. Callback Hell peerConnection.setRemoteDescription(object: SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { peerConnection.createAnswer(object : SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { } override fun onCreateSuccess(sdp: SessionDescription?) { peerConnection.setLocalDescription(object : SdpObserver { override fun onSetFailure(error: String?) { } override fun onSetSuccess() { } override fun onCreateSuccess(sdp: SessionDescription?) { // TODO: get audio/video tracks } override fun onCreateFailure(error: String?) { } }, sdp) } override fun onCreateFailure(error: String?) { } }, mediaConstraints) } override fun onCreateSuccess(sdp: SessionDescription?) { } override fun onCreateFailure(error: String?) { } }, sessionDescription)
7. Rx loadImageRx(url1) .zipWith(loadImageRx(url2), ::combineImages) .subscribe()
8. Rx loadImageRx(url1) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .zipWith(loadImageRx(url2), ::combineImages) .subscribe()
9. Sequential val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2)
10. Coroutines val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await())
11. async/await val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await())
12. async/await
13. Behind the Scenes val image1 = loadImage(url1) val image2 = loadImage(url2) val result = composeImages(image1, image2) displayImage(result)
14. Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map<String, Any?>, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) }
15. Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map<String, Any?>, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) }
16. Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map<String, Any?>, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image1 = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image1), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image2 = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image2), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) }
17. Behind the Scenes class Continuation(val label: Int, val context: Map<String, Any?>, val error: Throwable?) 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) }
18. Behind the Scenes fun load() = load(Continuation(0, emptyMap(), null))
19. Behind the Scenes class CoroutinesReversed { class Continuation(val label: Int, val context: Map<String, Any?>, val error: Throwable?) fun load(cont: Continuation) { when (cont.label) { 0 -> { cont.error?.let { throw it } val url1 = cont.context["url1"] as String val image = loadImage(url1) load(Continuation(1, cont.context.plus("image1" to image), null)) } 1 -> { cont.error?.let { throw it } val url2 = cont.context["url2"] as String val image = loadImage(url2) load(Continuation(2, cont.context.plus("image2" to image), null)) } 2 -> { cont.error?.let { throw it } val image1 = cont.context["image1"] as Image val image2 = cont.context["image2"] as Image val result = composeImages(image1, image2) load(Continuation(3, cont.context.plus("result" to result), null)) } 3 -> { val result = cont.context["result"] as Image displayImage(result) } } } fun load() = load(Continuation(0, emptyMap(), null)) }
20. Continuation public interface Continuation<in T> { public val context: CoroutineContext public fun resume(value: T) public fun resumeWithException(exception: Throwable) }
21. Retrofit suspend fun <T: Any> Call<T>.await(): T { return suspendCoroutine { cont -> enqueue(object: Callback<T> { override fun onResponse(call: Call<T>?, response: Response<T?>) { if (response.isSuccessful) { val body = response.body() ?: return cont.resumeWithException(NullPointerException()) cont.resume(body) } else { cont.resumeWithException(ApiError()) } } override fun onFailure(call: Call<T>?, t: Throwable) { cont.resumeWithException(t) } }) } }
22. Retrofit suspend fun <T: Any> Call<T>.await(): T { return suspendCoroutine { cont -> enqueue(object: Callback<T> { override fun onResponse(call: Call<T>?, response: Response<T?>) { if (response.isSuccessful) { val body = response.body() ?: return cont.resumeWithException(NullPointerException()) cont.resume(body) } else { cont.resumeWithException(ApiError()) } } override fun onFailure(call: Call<T>?, t: Throwable) { cont.resumeWithException(t) } }) } }
23. Retrofit dependencies { implementation 'com.jakewharton.retrofit:retrofit2-kotlin-coroutines- experimental-adapter:1.0.0' } Retrofit.Builder() .baseUrl(baseUrl) .client(client) .addConverterFactory(gsonConverterFactory) .addCallAdapterFactory(CoroutineCallAdapterFactory()) .build()
24. Retrofit interface ApiService { @GET fun loadTweets(): Call<List<Tweet>> }
25. Retrofit interface ApiService { @GET fun loadTweets(): Call<List<Tweet>> }
26. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<List<Tweet>> }
27. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<List<Tweet>> }
28. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<List<Tweet>> } launch { val tweets = service.loadTweets() displayTweets(tweets.await()) }
29. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<List<Tweet>> }
30. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<Response<List<Tweet>>> }
31. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<Response<List<Tweet>>> } launch { val deferred = service3.loadTweets() val response = deferred.await() if (response.isSuccessful) { response.body()?.let { displayTweets(it) } } }
32. Retrofit interface ApiService { @GET fun loadTweets(): Deferred<Response<List<Tweet>>> } launch { val deferred = service3.loadTweets() val response = deferred.await() if (response.isSuccessful) { response.body()?.let { displayTweets(it) } } }
33. async public fun <T> async( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, onCompletion: CompletionHandler? = null, block: suspend CoroutineScope.() -> T ): Deferred<T>
34. async public fun <T> async( context: CoroutineContext = DefaultDispatcher, start: CoroutineStart = CoroutineStart.DEFAULT, parent: Job? = null, onCompletion: CompletionHandler? = null, block: suspend CoroutineScope.() -> T ): Deferred<T>
35. await override suspend fun await(): T = awaitInternal() as T
36. Coroutine Builders val job = launch { } val deferred = async { } val result = runBlocking { }
37. launch/join val jobs = List(100_000) { launch { delay(5000) print(".") } } jobs.forEach { it.join() }
38. launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() }
39. launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() }
40. launch/join val jobs = List(100_000) { launch(context = CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() }
41. launch/join val jobs = List(100_000) { launch(CommonPool) { delay(5000) print(".") } } jobs.forEach { it.join() }
42. Coroutine Context val image1 = async { loadImage(url1) } val image2 = async { loadImage(url2) } val result = composeImages(image1.await(), image2.await())
43. Coroutine Context public interface CoroutineContext { public operator fun <E : Element> get(key: Key<E>): E? public fun <R> fold(initial: R, operation: (R, Element) -> R): R public operator fun plus(context: CoroutineContext): CoroutineContext public fun minusKey(key: Key<*>): CoroutineContext public interface Element : CoroutineContext public interface Key<E : Element> }
44. Coroutine Context log("Thread: ${Thread.currentThread().name}") log("Context: $coroutineContext") log("Job: ${coroutineContext[Job]}") log("Interceptor: ${coroutineContext[ContinuationInterceptor]}")
45. Coroutine Context Thread: ForkJoinPool.commonPool-worker-1
 Context: [DeferredCoroutine{Active}@424f90d, CommonPool]
 Job: DeferredCoroutine{Active}@424f90d
 Interceptor: CommonPool Thread: ForkJoinPool.commonPool-worker-2
 Context: [DeferredCoroutine{Active}@4ae30c2, CommonPool]
 Job: DeferredCoroutine{Active}@4ae30c2
 Interceptor: CommonPool
46. Retry • If at first you don’t succeed… • …Redefine success? • …Retry?
47. Retry val image1 = loadImage(url1) val image2 = loadImage(url1) composeImages(image1, image2)
48. Retry val image1 = retryIO { loadImage(url1) } val image2 = retryIO(times = 3) { loadImage(url1) } composeImages(image1, image2)
49. Retry val image1 = retryIO { loadImage(url1) } val image2 = retryIO(times = 3) { loadImage(url1) } composeImages(image1, image2)
50. retryIO suspend fun <T> retryIO( times: Int = Int.MAX_VALUE, initialDelay: Long = 100, // 0.1 second maxDelay: Long = 1000, // 1 second factor: Double = 2.0, block: suspend () -> T): T { var currentDelay = initialDelay repeat(times - 1) { try { return block() } catch (e: IOException) { Timber.e(e, "retryIO") } delay(currentDelay) currentDelay = (currentDelay * factor).toLong().coerceAtMost(maxDelay) } return block() // last attempt }
51. Lifecycle var job: Job? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) job = launch(UI) { // ... } } override fun onDestroy() { super.onDestroy() job?.cancel() }
52. Lifecycle var job: Job? = null override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) job = launch(UI) { // ... } } override fun onDestroy() { super.onDestroy() job?.cancel() }
53. Channels val channel = Channel<Int>() launch(CommonPool) { repeat(42) { channel.send(it)} } launch(UI) { for (i in channel) log("$i") }
54. Channels public interface Channel<E> : SendChannel<E>, ReceiveChannel<E> public interface SendChannel<in E> { public suspend fun send(element: E) public fun close(cause: Throwable? = null): Boolean } public interface ReceiveChannel<out E> { public suspend fun receive(): E public operator fun iterator(): ChannelIterator<E> }
55. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
56. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
57. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
58. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
59. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
60. Channels data class ActivityResult(val requestCode: Int, val resultCode: Int, val data: Intent?) private val activityResultChannel = Channel<ActivityResult>() override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) { launch { activityResultChannel.send(ActivityResult(requestCode, resultCode, data)) } } suspend fun startActivityForResultAsync(intent: Intent, requestCode: Int): ActivityResult { startActivityForResult(intent, requestCode) return activityResultChannel.receive() } launch { val result = startActivityForResultAsync(intent, 3) }
61. Channels val channel: Channel<String> = Channel() sendButton.setOnClickListener { launch(UI) { val text = usernameEditText.text.toString() channel.send(text) } }
62. Channels launch(UI) { for (string in channel) { resultTextView.text = string } }
63. Channels var job: Job? = null override fun onViewCreated(view: View, savedInstanceState: Bundle?) { job = launch(UI) { for (string in channel) { resultTextView.text = channel.receive() } } } override fun onDestroyView() { super.onDestroyView() job?.cancel() }
64. More Coroutines • Actors • Mutexes • Sequences
65. Sequences val fibonacci = buildSequence { yield(1) var cur = 1 var next = 1 while(true) { yield(next) val tmp = cur + next cur = next next = tmp } } fibonacci.take(5).map { it*it }
66. Kotlin 1.3 • No longer “experimental” • buildSequence and buildIterator moved to the kotlin.sequences package • Simplified Continuation<T>, only one method resumeWith(result:SuccessOrFailure<T>) • KT-16908 Support callable references to suspending functions • KT-18559 Serializability of all coroutine-related classes