Tackling Asynchrony with Kotlin Coroutines

Tackling Asynchrony
with Kotlin Coroutines
Presented By: PRAVEER GUPTA

fun getUserAddress(userId: Long): Address { … }
fun getRestaurants(address: Address): List<Restaurant> { … }
Sync or Async?

Reactive approach to Async
fun getUserAddress(userId: Long): Single<Address> { … }
fun getRestaurants(address: Address): Single<List<Restaurant>> { … }
Wrapped return types

Kotlin Coroutine’s approach to Async
suspend fun getUserAddress(userId: Long): Address { … }
suspend fun getRestaurants(address: Address): List<Restaurant> { … }
Suspend modiﬁer

Sync API Usage
fun showUserRestaurants(userId: Long) {
val address = getUserAddress(userId)
val restaurants = getRestaurants(address)
processRestaurants(restaurants)
}
Sequential & blocking

getUserAddress(userId)
.flatMap { address -> getRestaurants(address) }
.subscribe { restaurants -> processRestaurants(restaurants) }
}
Reactive API Usage
fun getUserAddress(userId: Long): Single<Address> { … }
fun getRestaurants(address: Address): Single<List<Restaurant>> { … }
Chained operators
& actions

Kotlin Coroutine API Usage
suspend fun showUserRestaurants(userId: Long) {
}
Suspend modiﬁer

Comparison
}
}
Synchronous
Asynchronous
using
Kotlin
Coroutines

Structure of
imperative synchronous code
is the same as
asynchronous code
(taken from KotlinConf 2018 - Exploring Coroutines in Kotlin by Venkat Subramaniam available on
YouTube)
Kotlin Coroutines

Kotlin Coroutines
No restructuring of code to a diﬀerent paradigm
Reuse existing language control ﬂows
Sequential vs Concurrent execution with coroutines
Complexities of async programming that coroutines handles

Kotlin Coroutines 101
import kotlinx.coroutines.*
fun main() = runBlocking {
launch {
delay(1000L)
println("World!")
}
println("Hello")
}
Output:
Hello
World!

launch {
delay(1000L)
println("World!")
}
println("Hello")
}
Coroutine Builders
Coroutine - an instance
of a suspendable
computation

launch {
delay(1000L)
println("World!")
}
println("Hello")
}
Suspending
function suspends
the execution of
the coroutine

Suspended coroutine
resumes with a
continuation block
public interface Continuation<in T> {
public val context: CoroutineContext
public fun resumeWith(result: Result<T>)
}
launch {
delay(1000L)
println("World!")
}
println("Hello")
}

launch {
doWorld()
}
println("Hello")
}
private suspend fun doWorld() {
delay(1000L)
println("World!")
}
Suspending function is
marked with a
suspend modiﬁer

org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2
org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.3.2
org.jetbrains.kotlinx:kotlinx-coroutines-reactive:1.3.2
Core Library
Integrations

}
Reuse existing Control ﬂows
How can you make the below
method resilient to failures?

try {
val address = withTimeout(200L) { getUserAddress(userId) }
val restaurants = withTimeout(300L) { getRestaurants(address) }
} catch (e: TimeoutCancellationException) {
// handle exception here
}
}
Exception handling using
standard try-catch block
Reuse existing Control ﬂows

Sequential vs Concurrent
suspend fun showUserDetails(userId: Long) {
val userInfo = getUserInfo(userId)
val orders = getUserOrders(userId)
combineAndBuild(userInfo, orders)
}
Two independent
calls to
external system
suspend fun getUserInfo(userId: Long): UserInfo { … }
suspend fun getUserOrders(userId: Long): List<Order> { … }

}
ﬁrst suspension

}
second suspension

}
ﬁnal call

}
sequential
execution
by default

coroutineScope {
val userInfo = async { getUserInfo(userId) }
val orders = async { getUserOrders(userId) }
combineAndBuild(userInfo.await(), orders.await())
}
}
concurrently executed
suspension
happens here

Structured Concurrency
coroutineScope {
}
}
When can a resource leakage happen?

Structured Concurrency
coroutineScope {
}
}
Exception in a coroutine results in its cancellation
1
2
3
4

Call to Action
https://kotlinlang.org/docs/reference/coroutines-overview.html
https://www.youtube.com/results?search_query=kotlin+coroutines
Give it a try on your next project

Thank You
https://praveergupta.in/
https://praveer09.github.io/

Tackling Asynchrony with Kotlin Coroutines

More Related Content

What's hot (20)

Similar to Tackling Asynchrony with Kotlin Coroutines (20)

More from Tech Triveni (20)

Recently uploaded (20)

Tackling Asynchrony with Kotlin Coroutines