Deep dive into Coroutines on JVM @ KotlinConf 2017

elizarov at JetBrains
Roman Elizarov
Deep dive into Coroutines
on JVM

Continuation Passing
Style (CPS)

A toy problem
fun postItem(item: Item) {
val token = requestToken()
val post = createPost(token, item)
processPost(post)
}
Direct style

Direct style
processPost(post)
}

Direct style
processPost(post)
}
Continuation

Continuation-Passing Style
requestToken { token ->
processPost(post)
}
}
Continuation
CPS == Callbacks

Continuation-Passing Style
createPost(token, item) { post ->
processPost(post)
}
}
}

Coroutines Direct Style
suspend fun postItem(item: Item) {
processPost(post)
}

How does it work?
Behind the scenes

Kotlin suspending functions
Kotlin
suspend fun createPost(token: Token, item: Item): Post { … }

CPS Transformation
Java/JVM
Object createPost(Token token, Item item, Continuation<Post> cont) { … }

CPS Transformation
callback
Java/JVM

Continuation
interface Continuation<in T> {
val context: CoroutineContext
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}

Continuation
Continuation is a generic callback interface
interface Continuation<in T> {
val context: CoroutineContext
fun resume(value: T)
fun resumeWithException(exception: Throwable)
}

Direct code
processPost(post)
}

Continuations
processPost(post)
}
Initial continuation

Continuations
processPost(post)
}
Continuation

Continuations
processPost(post)
}
Continuation
Convert to CPS?

Callbacks?
processPost(post)
}
}
}

Labels
// LABEL 0
// LABEL 1
// LABEL 2
processPost(post)
}

Labels
switch (label) {
case 0:
case 1:
case 2:
processPost(post)
}
}

val sm = object : CoroutineImpl { … }
switch (sm.label) {
case 0:
case 1:
case 2:
processPost(post)
}
}
State

fun postItem(item: Item, cont: Continuation) {
switch (sm.label) {
case 0:
requestToken(sm)
case 1:
createPost(token, item, sm)
case 2:
processPost(post)
}
}
CPS Transform

val sm = …
switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
case 2:
processPost(post)
}
}
Save state

switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
case 2:
processPost(post)
}
}
Callback
State Machine as Continuation

val sm = object : CoroutineImpl {
fun resume(…) {
postItem(null, this)
}
}
switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
…
}
Callback

val sm = cont as? ThisSM ?: object : ThisSM {
fun resume(…) {
postItem(null, this)
}
}
switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
…
}
Callback

val sm = …
switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
val item = sm.item
val token = sm.result as Token
sm.label = 2
…
}
Restore state

val sm = …
switch (sm.label) {
case 0:
sm.item = item
sm.label = 1
requestToken(sm)
case 1:
val item = sm.item
val token = sm.result as Token
sm.label = 2
…
}
Continue

State Machine vs Callbacks
processPost(post)
}
}
}
processPost(post)
}

processPost(post)
}
}
}
processPost(post)
}
Reuse closure / state object
Create new closure

suspend fun postItems(items: List<Item>) {
for (item in items) {
processPost(post)
}
}
Easy loops and
higher-order functions

fun postItems(items: List<Item>) {
…
}
suspend fun postItems(items: List<Item>) {
for (item in items) {
processPost(post)
}
}
A horrid callback mess
Easy loops and
higher-order functions

interface Service {
fun createPost(token: Token, item: Item): Call<Post>
}

interface Service {
fun createPost(token: Token, item: Item): Call<Post>
}
suspend fun createPost(token: Token, item: Item): Post =
serviceInstance.createPost(token, item).await()

suspend fun <T> Call<T>.await(): T {
…
}

Callbacks everywhere
suspend fun <T> Call<T>.await(): T {
enqueue(object : Callback<T> {
override fun onResponse(call: Call<T>, response: Response<T>) {
// todo
}
override fun onFailure(call: Call<T>, t: Throwable) {
// todo
}
})
}

suspend fun <T> Call<T>.await(): T = suspendCoroutine { cont ->
if (response.isSuccessful)
cont.resume(response.body()!!)
else
cont.resumeWithException(ErrorResponse(response))
}
cont.resumeWithException(t)
}
})
}

suspend fun <T> suspendCoroutine(block: (Continuation<T>) -> Unit): T

suspend fun <T> suspendCoroutine(block: (Continuation<T>) -> Unit): T
Regular function
Inspired by call/cc from Scheme

Install callback
else
}
}
})
}

Analyze response
else
}
}
})
}

Analyze response
else
}
}
})
}
That’s all

Out-of-the box integrations
kotlinx-coroutines-core
jdk8
guava
nio
reactor
rx1
rx2
Contributions are welcome

What thread it resumes on?
processPost(post)
}
Continuation
It depends!

What thread it resumes on?
launch(UI) {
processPost(post)
}
}
Continuation

Continuation Interceptor
interface ContinuationInterceptor : CoroutineContext.Element {
companion object Key : CoroutineContext.Key<ContinuationInterceptor>
fun <T> interceptContinuation(continuation: Continuation<T>):
Continuation<T>
}

Dispatched continuation
class DispatchedContinuation<in T>(
val dispatcher: CoroutineDispatcher,
val continuation: Continuation<T>
): Continuation<T> by continuation {
override fun resume(value: T) {
dispatcher.dispatch(context, DispatchTask(…))
}
…
} Dispatches execution to another thread

fun <T> future(
context: CoroutineContext = DefaultDispatcher,
block: suspend () -> T
): CompletableFuture<T>
Coroutine builder

fun <T> future(
A regular function

fun <T> future(

fun <T> future(
): CompletableFuture<T> suspending lambda

fun <T> future(
): CompletableFuture<T> {
val future = CompletableFuture<T>()
block.startCoroutine(…)
return future
}

fun <T> future(
): CompletableFuture<T> {
block.startCoroutine(completion = object : Continuation<T> {
…
})
return future
}

fun <T> future(…): CompletableFuture<T> {
override val context: CoroutineContext get() = context
future.complete(value)
}
override fun resumeWithException(exception: Throwable) {
future.completeExceptionally(exception)
}
})
return future
}

fun <T> future(…): CompletableFuture<T> {
override val context: CoroutineContext get() = context
future.complete(value)
}
override fun resumeWithException(exception: Throwable) {
future.completeExceptionally(exception)
}
})
return future
}
That’s all, folks!

Launch coroutine builder
fun launch(
block: suspend () -> Unit
): Job { … }

Launching coroutine
val job = launch {
…
}

val job = launch {
…
}
job.join()

val job = launch {
…
}
job.join()
job.cancel()

Job
interface Job : CoroutineContext.Element {
companion object Key : CoroutineContext.Key<Job>
…
}

Using coroutine context
launch {
val job = coroutineContext[Job]!!
…
}

Using coroutine context
launch {
val job = coroutineContext[Job]!!
val interceptor = coroutineContext[CoroutineInterceptor]!!
…
}

Timeouts
launch {
withTimeout(10, TimeUnit.SECONDS) {
…
}
}

Cooperative cancellation
launch {
while (true) {
…
}
}

launch {
while (isActive) {
…
}
}

launch {
while (true) {
delay(…)
…
}
}

Cancellable suspension
suspend fun <T> Call<T>.await(): T =
suspendCancellableCoroutine { cont ->
enqueue(…)
}

Cancellable continuation
suspendCancellableCoroutine { cont: CancellableContinuation<T> ->
enqueue(…)
}

Completion handler
suspendCancellableCoroutine { cont: CancellableContinuation<T> ->
enqueue(…)
cont.invokeOnCompletion {
this@await.cancel()
}
}

Communicating Sequential
Processes (CSP)

Shared Mutable State
@stefanobaghino

The choice
Shared
Mutable State
Share by
Communicating

Example
fun main(args: Array<String>) = runBlocking<Unit> {
val chan = Channel<Int>()
launch(coroutineContext) {
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Main coroutine
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Channel
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Launch
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}
Child coroutine

Coroutine body
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}
Sequential code!

Send
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Close
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Receive for loop
repeat(10) { i ->
delay(100)
chan.send(i)
}
chan.close()
}
for (i in chan) {
println(i)
}
}
}

Actors
The other way to look at CSP

The choice
Named
channels
Named
coroutines
Actor == named coroutine & inbox channel

Example
val printer = actor<Int>(coroutineContext) {
for (i in channel) {
println(i)
}
}
repeat(10) { i ->
delay(100)
printer.send(i)
}
printer.close()
}
}

Actor coroutine builder
println(i)
}
}
repeat(10) { i ->
delay(100)
printer.send(i)
}
printer.close()
}
}

Actor body
println(i)
}
}
repeat(10) { i ->
delay(100)
printer.send(i)
}
printer.close()
}
}
Sequential!

Interacting with an actor
println(i)
}
}
repeat(10) { i ->
delay(100)
printer.send(i)
}
printer.close()
}
}

Guide to kotlinx.coroutines
by example
https://github.com/Kotlin/kotlinx.coroutines/blob/master/coroutines-guide.md
• Basics
• Cancellation and Timeouts
• Composition
• Coroutine contexts
• Channels
• Shared Mutable State and Concurrency
• Select expressions

#kotlinconf17
relizarov
elizarov at JetBrains
Roman Elizarov
Thank you
Any questions?

Deep dive into Coroutines on JVM @ KotlinConf 2017

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Deep dive into Coroutines on JVM @ KotlinConf 2017 (20)

More from Roman Elizarov (17)

Recently uploaded (20)

Deep dive into Coroutines on JVM @ KotlinConf 2017