Introduction to Coroutines @ KotlinConf 2017

elizarov at JetBrains
Roman Elizarov
Introduction to Coroutines

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
2
Kotlin

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

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

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

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

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())
}
Everything like in blocking code

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

Retrofit async
interface Service {
}
future

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

Retrofit async
interface Service {
}
natural signature

Retrofit async
interface Service {
}
Suspending extension function
from integration library

Higher-order functions
val post = retryIO {
}

val post = retryIO { createPost(token, item) }
suspend fun <T> retryIO(block: suspend () -> T): T {
var curDelay = 1000L // start with 1 sec
while (true) {
try {
return block()
} catch (e: IOException) {
e.printStackTrace() // log the error
}
delay(curDelay)
curDelay = (curDelay * 2).coerceAtMost(60000L)
}
}

while (true) {
try {
return block()
}
delay(curDelay)
}
}
suspending lambda

while (true) {
try {
return block()
}
delay(curDelay)
}
}
Everything like in blocking code

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 executionA regular function cannot

processPost(post)
}
Can suspend executionA 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 { … }

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)
C#
async Task<Token> requestToken() { … }
async Task<Post> createPost(Token token, Item item) { … }
void processPost(Post post) { … }

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

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

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

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

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;
and then wait for them
C#

Use-case for async
var result = combineImages(image1, image2);
C#

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

async { … }
Kotlin
A regular function

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()
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

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

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

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> =
future {
val future1 = loadImageAsync(name1)
combineImages(future1.await(), future2.await())
}
Kotlin
Java

name1: String,
name2: String
future {
}
future coroutine builder
Kotlin
Java

name1: String,
name2: String
future {
}
Extension for Java’s CompletableFuture
Kotlin
Java

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

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

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

The same building blocks
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

Synchronous
var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
val iter = fibonacci.iterator()

var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
println(iter.next())

var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
println(iter.next()) // 1

var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
println(iter.next())

var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}

var cur = 1
var next = 1
while (true) {
yield(cur)
cur = next
next = tmp
}
}
Synchronous with invoker

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 status
Coroutines are here to stay
Backwards compatible inside 1.1 & 1.2
To be finalized in the future

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

Introduction to Coroutines @ KotlinConf 2017

More Related Content

What's hot

Similar to Introduction to Coroutines @ KotlinConf 2017

More from Roman Elizarov

Recently uploaded

Introduction to Coroutines @ KotlinConf 2017