Kotlin Coroutines - the new async

Kotlin Coroutines - the new async
Bartłomiej Osmałek

Coroutines - the not-so-new async

Kotlin Coroutines
• Asynchronous

• Cooperative multitasking

• Single-threaded*

• Non-blocking

Non-blocking
Coroutine 1
Coroutine 2
Thread 1
Thread 2
waits for Coroutine 2
Coroutine 3
Dispatcher starts Coroutine 2
starts Coroutine 3

fun loadDataForUI() {
showOnUi(getSomeValue())
}
fun getSomeValue(): Int {
//some serious calculation
return 5
}

fun loadDataForUI() {
}
suspend fun getSomeValue(): Int {
delay(timeMillis = 5000)
return 5
}

fun loadDataForUI() = runBlocking {
}
return 5
}

suspend fun loadDataForUI() {
}
return 5
}

val someValue = getSomeValue()
showOnUi(someValue)
}
suspend fun getSomeValue(): Int {…}

val someValue = getSomeValue()
//do something else
showOnUi(someValue)
}

suspend fun loadDataForUI() = coroutineScope {
val someValue = async { getSomeValue() }
//do something else
showOnUi(someValue.await())
}

launch async
Return value Job Deferred<T>
Suspend till ﬁnish join(): Unit await(): T
Error handling Propagate to parent
Throws when called
await

Each coroutine needs a Coroutine Scope

coroutineScope
• Waits for all child coroutines to complete

• Cancels other child coroutines if any fails

• Provides CoroutineContext

• Can limit coroutine lifetime

abstract class BaseViewModel : ViewModel(), CoroutineScope {
override val coroutineContext = Dispatchers.IO + Job()
@CallSuper
override fun onCleared() {
coroutineContext.cancel()
}
}

CoroutineContext
• Provides parent job

• Provides error handler

• Provides dispatcher

Dispatcher
• Provides threads for coroutine execution*

• Available dispatchers:

‣ Dispatchers.Default

‣ Dispatchers.Main

‣ Dispatchers.IO

‣ Dispatchers.Unconﬁned

Unconﬁned can be tricky
fun main(args: Array<String>) = runBlocking<Unit> {
launch {
log("Hello")
delay(100)
log("World")
}
log("Launched!")
}
Output:
[main] Launched!
[main] Hello
[main] World

launch(Dispatchers.Unconfined) {
log("Hello")
delay(100)
log("World")
}
log("Launched!")
}
Output:
[main] Hello
[main] Launched!
[kotlinx.coroutines.DefaultExecutor] World

val job = launch(Dispatchers.IO) {
log("do nothing")
}
log("Hello")
job.join()
log("World")
}
log("Launched!")
}
Output:
[main] Hello
[DefaultDispatcher-worker-1] do nothing
[main] World
[main] Launched!

val job = launch(Dispatchers.IO) {
log("do nothing")
delay(100)
}
log("Hello")
job.join()
log("World")
}
log("Launched!")
}
Output:
[DefaultDispatcher-worker-1] do nothing
[main] Hello
[main] Launched!
[DefaultDispatcher-worker-1] World

Canceling coroutine
var job = Job()
job = launch {
log("Hello")
delay(100)
log("World")
}
log("Launched!")
job.cancel()
}
Output:
[main] Launched!

Canceling coroutine
var job = Job()
job = launch {
log("Hello")
job.cancel()
delay(100)
log("World")
}
log("Launched!")
}
Output:
[main] Launched!
[main] Hello

Canceling coroutine
var job = Job()
job = launch {
log("Hello")
job.cancel()
Thread.sleep(100)
log("World")
}
log("Launched!")
}
Output:
[main] Launched!
[main] Hello
[main] World

Canceling coroutine
var job = Job()
job = launch {
log("Hello")
job.cancel()
Thread.sleep(100)
yield()
log("World")
}
log("Launched!")
}
Output:
[main] Launched!
[main] Hello

Ok, but give some real use cases!

//in ViewModel
val appId = async(start = CoroutineStart.LAZY) { // Dispatchers.IO
pairingInteractor.fetchAppId()
}
//in Fragment
private fun fetchAppId() {
launch { // Dispatchers.Main
val appId = viewModel.appId.await()
appIdTextView.text = appId
}
}

suspend fun updateAndSynchronize() = coroutineScope {
val appStatus = statusRepository.fetchAppStatus(forceRefresh = true)
val jobs = appStatus.versions
.forEach { (versionable, versionFromAppStatus) ->
val updater = updaterFactory.create(versionable)
if (versionFromAppStatus > updater.getCurrentVersion()) {
launch { updater.update(versionFromAppStatus) }
}
}
}

suspend fun checkServerIsValid(serverUrl: String): ServerCheckResult {
return try {
serverRepository.getServerInfo(serverUrl)
ServerCheckResult.VALID_SERVER
} catch (e: Exception) {
when (e) {
is IllegalArgumentException -> ServerCheckResult.INVALID_URL
is JsonEncodingException -> ServerCheckResult.INVALID_SERVER
is IOException -> ServerCheckResult.NO_CONNECTION
else -> ServerCheckResult.INVALID_SERVER
}
}
}

suspend fun checkServerIsValid(serverUrl: String): Result<ServerCheckResult> {
return runCatching {
serverRepository.getServerInfo(serverUrl)
ServerCheckResult.VALID_SERVER
}
}

Bartłomiej Osmałek
Android Developer @ Droids on Roids

Co-organizer @ GDG Wrocław
Nonda95
@nonda95
nonda1995
bartlomiej-osmalek
Thanks!

Kotlin Coroutines - the new async

More Related Content

What's hot (20)

Similar to Kotlin Coroutines - the new async (20)

Recently uploaded (20)

Kotlin Coroutines - the new async