Fresh Async with Kotlin

Fresh Async With Kotlin
Presented at QCon SF, 2017
/Roman Elizarov @ JetBrains

InfoQ.com: News & Community Site
• Over 1,000,000 software developers, architects and CTOs read the site world-
wide every month
• 250,000 senior developers subscribe to our weekly newsletter
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• 2 dedicated podcast channels: The InfoQ Podcast, with a focus on
Architecture and The Engineering Culture Podcast, with a focus on building
• 96 deep dives on innovative topics packed as downloadable emags and
minibooks
• Over 40 new content items per week
Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
kotlin-async

Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide
Presented at QCon San Francisco
www.qconsf.com

Speaker: Roman Elizarov
• 16+ years experience
• Previously developed high-perf trading software
@ Devexperts
• Teach concurrent & distributed programming
@ St. Petersburg ITMO University
• Chief judge
@ Northern Eurasia Contest / ACM ICPC
• Now team lead in Kotlin Libraries
@ JetBrains

Pragmatic. Concise. Modern. Interoperable with Java.

How do we write code that waits for
something most of the time?

A toy problem
Kotlin fun requestToken(): Token {
// makes request for a token & waits
return token // returns result when received
}
1

fun requestToken(): Token { … }
fun createPost(token: Token, item: Item): Post {
// sends item to the server & waits
return post // returns resulting post
}
A toy problem
Kotlin
2

fun createPost(token: Token, item: Item): Post { … }
fun processPost(post: Post) {
// does some local processing of result
}
A toy problem
Kotlin
3

fun processPost(post: Post) { … }
A toy problem
Kotlin
fun postItem(item: Item) {
val token = requestToken()
val post = createPost(token, item)
processPost(post)
}
1
2
3
Can be done with threads!

fun requestToken(): Token {
// makes request for a token
// blocks the thread waiting for result
}
Threads
processPost(post)
}
Is anything wrong with it?

How many threads we can have?
100 🙂

1000 😅

10 000 😩

100 000 😵

Callbacks to the rescue
Sort of …

Callbacks: before
fun requestToken(): Token {
// makes request for a token & waits
}
1

Callbacks: after
fun requestTokenAsync(cb: (Token) -> Unit) {
// makes request for a token, invokes callback when done
// returns immediately
}
1
callback

Callbacks: before
fun requestTokenAsync(cb: (Token) -> Unit) { … }
fun createPost(token: Token, item: Item): Post {
// sends item to the server & waits
return post // returns resulting post
}
2

Callbacks: after
fun createPostAsync(token: Token, item: Item,
cb: (Post) -> Unit) {
// sends item to the server, invokes callback when done
}
2
callback

Callbacks: before
cb: (Post) -> Unit) { … }
processPost(post)
}

Callbacks: after
cb: (Post) -> Unit) { … }
requestTokenAsync { token ->
createPostAsync(token, item) { post ->
processPost(post)
}
}
}
aka “callback hell”
This is simplified. Handling
exceptions makes it a real mess

Futures/Promises/Rx
to the rescue
Sort of …

Futures: before
fun requestTokenAsync(cb: (Token) -> Unit) {
// makes request for a token, invokes callback when done
}
1

Futures: after
fun requestTokenAsync(): Promise<Token> {
// returns promise for a future result immediately
}
1
future

Futures: before
fun requestTokenAsync(): Promise<Token> { … }
cb: (Post) -> Unit) {
// sends item to the server, invokes callback when done
}
2

Futures: after
fun createPostAsync(token: Token, item: Item): Promise<Post> {
// sends item to the server
}
future
2

Futures: before
fun createPostAsync(token: Token, item: Item): Promise<Post> …
requestTokenAsync { token ->
createPostAsync(token, item) { post ->
processPost(post)
}
}
}

Futures: after
requestTokenAsync()
.thenCompose { token -> createPostAsync(token, item) }
.thenAccept { post -> processPost(post) }
}
Composable &
propagates exceptions
No nesting indentation

Futures: after
requestTokenAsync()
}
But all those combinators…

Kotlin coroutines to the rescue
Let’s get real

Coroutines: before
fun requestTokenAsync(): Promise<Token> {
}
1

Coroutines: after
suspend fun requestToken(): Token {
// makes request for a token & suspends
}
1
natural signature

Coroutines: before
suspend fun requestToken(): Token { … }
fun createPostAsync(token: Token, item: Item): Promise<Post> {
// sends item to the server
}
2

Coroutines: after
suspend fun createPost(token: Token, item: Item): Post {
// sends item to the server & suspends
return post // returns result when received
}
2
natural signature

Coroutines: before
suspend fun createPost(token: Token, item: Item): Post { … }
requestTokenAsync()
}

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

Coroutines: after
processPost(post)
}
Like regular code

Coroutines: after
processPost(post)
}
suspension
points

• Regular loops
Bonus features
for ((token, item) in list) {
createPost(token, item)
}

• Regular exception handing
Bonus features
try {
} catch (e: BadTokenException) {
…
}

• Regular higher-order functions
• forEach, let, apply, repeat, filter, map, use, etc
Bonus features
file.readLines().forEach { line ->
createPost(token, line.toItem())
}

• Custom higher-order functions
Bonus features
val post = retryIO {
}
Everything like in blocking code

How does it work?
A quick peek behind the scenes

Kotlin suspending functions
callback
Kotlin
Java/JVM
Object createPost(Token token, Item item, Continuation<Post> cont) { … }

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

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

Code with suspension points
Kotlin
Java/JVM
Compiles to state machine
(simplified code shown)
processPost(post)
switch (cont.label) {
case 0:
cont.label = 1;
requestToken(cont);
break;
case 1:
Token token = (Token) prevResult;
cont.label = 2;
createPost(token, item, cont);
break;
case 2:
Post post = (Post) prevResult;
processPost(post);
break;
}

Code with suspension points
Kotlin
Java/JVM
processPost(post)
switch (cont.label) {
case 0:
cont.label = 1;
requestToken(cont);
break;
case 1:
Token token = (Token) prevResult;
cont.label = 2;
createPost(token, item, cont);
break;
case 2:
Post post = (Post) prevResult;
processPost(post);
break;
}

Integration
Zoo of futures on JVM

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

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

interface Service {
}
suspend fun createPost(token: Token, item: Item): Post =
serviceInstance.createPost(token, item).await()
Suspending extension function
from integration library

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

Coroutine builders
How can we start a coroutine?

Coroutines revisited
processPost(post)
}

processPost(post)
}

processPost(post)
}
Error: Suspend function 'requestToken' should be called only from
a coroutine or another suspend function

processPost(post)
}
Can suspend execution

processPost(post)
}
Can suspend execution A regular function cannot

processPost(post)
}
Can suspend execution A regular function cannot
One cannot simply invoke a
suspending function

Launch
launch {
processPost(post)
}
}
coroutine builder

launch {
processPost(post)
}
}
Fire and forget!
Returns immediately, coroutine works
in background thread pool

launch {
processPost(post)
}
}

launch(UI) {
processPost(post)
}
}
UI Context
Just specify the context

launch(UI) {
processPost(post)
}
}
UI Context
And it gets executed on UI thread

Where’s the magic of launch?

fun launch(
context: CoroutineContext = DefaultDispatcher,
block: suspend () -> Unit
): Job { … }
A regular function

fun launch(
): Job { … } suspending lambda

fun launch(
): Job { … }

async / await
The classic approach

Kotlin-way
processPost(post)
}
Kotlin

async Task postItem(Item item) {
var token = await requestToken();
var post = await createPost(token, item);
processPost(post);
}
Classic-way
C# approach to the same problem (also
Python, TS, Dart, coming to JS)
async Task<Token> requestToken() { … }
async Task<Post> createPost(Token token, Item item) { … }
void processPost(Post post) { … }
C#

processPost(post);
}
Classic-way
mark with async
C#

processPost(post);
}
Classic-way
use await to suspend
C#

processPost(post);
}
Classic-way
returns a future
C#

Why no await keyword in Kotlin?
The problem with async
requestToken() VALID –> produces Task<Token>
await requestToken() VALID –> produces Token
concurrent behavior
sequential behavior
C#
C#
default
Concurrency is hard
Concurrency has to be explicit

Kotlin suspending functions are
designed to imitate sequential behavior
by default
Concurrency is hard
Concurrency has to be explicit

Kotlin approach to async
Concurrency where you need it

Use-case for async
async Task<Image> loadImageAsync(String name) { … }C#

Use-case for async
var promise1 = loadImageAsync(name1);
async Task<Image> loadImageAsync(String name) { … }
Start multiple operations
concurrently
C#

Use-case for async
var image1 = await promise1;
async Task<Image> loadImageAsync(String name) { … }
and then wait for them
C#

Use-case for async
var result = combineImages(image1, image2);
async Task<Image> loadImageAsync(String name) { … }C#

Kotlin async function
fun loadImageAsync(name: String): Deferred<Image> =
async { … }
Kotlin

async { … }
A regular function
Kotlin

async { … }
Kotlin’s future type
Kotlin

async { … }
async coroutine builder
Kotlin

async { … }
val deferred1 = loadImageAsync(name1)
Start multiple operations
concurrently
Kotlin

async { … }
val image1 = deferred1.await()
val image2 = deferred2.await() and then wait for them
await function
Suspends until deferred is complete
Kotlin

async { … }
val result = combineImages(image1, image2)
Kotlin

Using async function when needed
suspend fun loadImage(name: String): Image { … }
Is defined as suspending function, not async

Using async function when needed
suspend fun loadImage(name: String): Image { … }
suspend fun loadAndCombine(name1: String, name2: String): Image {
val deferred1 = async { loadImage(name1) }
val deferred2 = async { loadImage(name2) }
return combineImages(deferred1.await(), deferred2.await())
}

Kotlin approach to async
requestToken() VALID –> produces Token
async { requestToken() } VALID –> produces Deferred<Token>
sequential behavior
concurrent behavior
Kotlin
Kotlin
default

What are coroutines
conceptually?

What are coroutines
conceptually?
Coroutines are like very light-weight threads

fun main(args: Array<String>) = runBlocking<Unit> {
val jobs = List(100_000) {
launch {
delay(1000L)
print(".")
}
}
jobs.forEach { it.join() }
}
Example

launch {
delay(1000L)
print(".")
}
}
}
Example This coroutine builder runs coroutine in
the context of invoker thread

launch {
delay(1000L)
print(".")
}
}
}
Example
Suspends for 1 second

launch {
delay(1000L)
print(".")
}
}
}
Example
We can join a job just
like a thread

launch {
delay(1000L)
print(".")
}
}
}
Example
Try that with 100k threads!
Prints 100k dots after one second delay

fun main(args: Array<String>) {
thread {
Thread.sleep(1000L)
print(".")
}
}
}
Example

fun main(args: Array<String>) {
thread {
Thread.sleep(1000L)
print(".")
}
}
}
Example
Exception in thread "main" java.lang.OutOfMemoryError: unable to create new native thread

Java interop
Can we use Kotlin coroutines with Java code?

Java interop
CompletableFuture<Image> loadImageAsync(String name) { … }Java

CompletableFuture<Image> loadImageAsync(String name) { … }
CompletableFuture<Image> loadAndCombineAsync(String name1,
String name2)
Java
Imagine implementing it in Java…

CompletableFuture<Image> loadImageAsync(String name) { … }
CompletableFuture<Image> loadAndCombineAsync(String name1,
String name2)
{
CompletableFuture<Image> future1 = loadImageAsync(name1);
CompletableFuture<Image> future2 = loadImageAsync(name2);
return future1.thenCompose(image1 ->
future2.thenCompose(image2 ->
CompletableFuture.supplyAsync(() ->
combineImages(image1, image2))));
}
Java

fun loadAndCombineAsync(
name1: String,
name2: String
): CompletableFuture<Image> =
…
Kotlin

name1: String,
name2: String
future {
val future1 = loadImageAsync(name1)
combineImages(future1.await(), future2.await())
}
Kotlin

name1: String,
name2: String
future {
combineImages(future1.await(), future2.await())
}
Kotlin
future coroutine builder

Beyond asynchronous code
Kotlin’s approach to generate/yield – synchronous coroutines

Fibonacci sequence
val fibonacci: Sequence<Int> = …

Fibonacci sequence
val fibonacci = buildSequence {
var cur = 1
var next = 1
while (true) {
yield(cur)
val tmp = cur + next
cur = next
next = tmp
}
}

Fibonacci sequence
var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
A coroutine builder with
restricted suspension

Fibonacci sequence
var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
A suspending function

The same building blocks
public fun <T> buildSequence(
builderAction: suspend SequenceBuilder<T>.() -> Unit
): Sequence<T> { … }

Result is a synchronous sequence

Suspending lambda with receiver

@RestrictsSuspension
abstract class SequenceBuilder<in T> {
abstract suspend fun yield(value: T)
}
Coroutine is restricted only to
suspending functions defined here

Library vs Language
Keeping the core language small

Classic async
async/await
generate/yield
Keywords

Kotlin coroutines
suspend Modifier

Kotlin coroutines
Standard
library

Kotlin coroutines
Standard
library
kotlinx-coroutines
launch, async, runBlocking,
future, delay,
Job, Deferred, etc
http://github.com/kotlin/kotlinx.coroutines

Experimental in Kotlin 1.1 & 1.2
Coroutines can be used in production
Backwards compatible inside 1.1 & 1.2
To be finalized in the future

Thank you
Any questions?
Slides are available at www.slideshare.net/elizarov
email me to elizarov at gmail
relizarov

Watch the video with slide
synchronization on InfoQ.com!
https://www.infoq.com/presentations/
kotlin-async

Fresh Async with Kotlin

More Related Content

Similar to Fresh Async with Kotlin

More from C4Media

Recently uploaded

Fresh Async with Kotlin