Programação Assíncrona com Kotlin Coroutines

ProgramaçãoProgramação
Assíncrona comAssíncrona com
Kotlin CoroutinesKotlin Coroutines
2019

Async:Async:
Concorrência &Concorrência &
ParalelismoParalelismo

SequencialSequencial
1. CPU ociosa
2. Main Thread bloqueada
3. Congelamento do app

Exemplo:Exemplo:
Atualização de PDVsAtualização de PDVs

AbordagensAbordagens
1. Síncrona
2. Com Threads
3. Com Coroutines

Síncrono - CódigoSíncrono - Código
fun getAmePrices() : List<Price> { ... }
fun getAmeProducts(): List<Product> { ... }
fun savePriceProductToStore(prices: List<Price>, products: List<Product>) { ... }
fun postNotificationToPOS(posId: Int) : Response { ... }
fun updatePosAssortment(posId): Response{
val prices = getAmePrices()
val products = getAmeProducts()
val savePriceAndProductToPOS(prices, products)
return postNotificationToPOS(posId)
}

Threads - InterfaceThreads - Interface
fun thread(
start: Boolean = true,
isDaemon: Boolean = false,
contextClassLoader: ClassLoader? = null,
name: String? = null,
priority: Int = -1,
block: () -> Unit
): Thread

Threads - CódigoThreads - Código
fun updatePosAssortment(posId: Int): Response{
val savePriceAndProductToPOS(prices, products)
}
for(pos in posList){
thread(start=true){
updatePosAssortment(pos.posId)
}
}

Threads - FluxoThreads - Fluxo

Threads - DesvantagensThreads - Desvantagens
Quanto mais threads:
1. Maior trabalho pro SO
2. Maior consumo de memória
3. Maior tempo de CPU ociosa

Coroutines - InterfaceCoroutines - Interface
fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job (source)

Coroutines - CódigoCoroutines - Código
suspend fun getAmePrices() : List<Price> { ... }
suspend fun getAmeProducts(): List<Product> { ... }
suspend fun savePriceProductToStore(prices: List<Price>, products: List<Product>)
{ ... }
suspend fun postNotificationToPOS(posId: Int) : Response { ... }
suspend fun updatePosAssortment(posId): Response{
val savePriceProductToPOS(prices, products)
}

runBlocking {
posList.forEach {
launch(Dispatchers.Default) {
updatePosAssortment(it.posId)
}
}
}

val responses = mutableListOf<Response>()
runBlocking {
posList.map {
async(Dispatchers.IO) {
updatePosAssortment(it.posId).await()
}
}.forEach {
responses.add(it.await())
}
}

Coroutines - ProcessoCoroutines - Processo

Mas como funciona?Mas como funciona?

Continuation on Direct StyleContinuation on Direct Style
}

}
Continuation

fun updatePosAssortment(store): Response{
}
Continuation

Continuation-Passing StyleContinuation-Passing Style
Continuation
getAmePrices { prices ->
postNotificationToPOS(posId)
}
}

Continuation
getAmeProducts { products ->
}
}
}

Continuation
getAmeProducts { products ->
savePriceProductToPOS(prices, products) {
}
}
}
}

CPS em KotlinCPS em Kotlin
suspend fun updatePosAssortment(posId : Int): Response { ... }
Object updatePosAssortment(Int posId, Continuation<Response> cont) { ... }
Compilação JVM

Máquina de estadosMáquina de estados
suspend fun updatePosAssortment(posId: Int): Response{
//LABEL 0
//LABEL 1
//LABEL 2
//LABEL 3
}

switch (label){
case 0:
case 1:
case 2:
case 3:
}
}

val sm = object : CoroutineImpl { ... }
switch (label){
case 0:
sm.label = 1
sm.posId = posId
val prices = getAmePrices(sm)
case 1:
case 2:
case 3:
}
}

Pontos relevantesPontos relevantes
1. Coroutines com Java
2. Bibliotecas Java são usadas em Kotlin
3. “Coroutines are light-weight threads”

Programação Assíncrona com Kotlin Coroutines

More Related Content

What's hot (7)

Similar to Programação Assíncrona com Kotlin Coroutines (20)

Recently uploaded (20)

Programação Assíncrona com Kotlin Coroutines