Grokking Coroutines @danlew42

“Essentially, coroutines are light-weight threads.” ~Kotlin Documentation

myScope.launch { val image = downloadImage() displayImage(image) } suspend fun downloadImage() = withContext(Dispatchers.IO) { … } fun displayImage(image: Image)

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

What are coroutines?

Subroutines fun sumSquaredValues(values: List): Int { return values.sumBy { value -> square(value) } } fun square(value: Int): Int = value * value

Routine Subroutine

Coroutine Coroutine

val iterator = sequence.iterator() while (iterator.hasNext()) { val next = iterator.next() println(next) } sequence { var cur = 1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } Consumer Producer

val iterator = sequence.iterator() while (iterator.hasNext()) { val next = iterator.next() println(next) } sequence { var cur = 1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } Consumer Producer

No content

class Fibonacci { var cur = 1 var next = 1 fun next(): Int { val toReturn = cur val tmp = cur + next cur = next next = tmp return toReturn } } sequence { var cur = 1 var next = 1 while (true) { yield(cur) val tmp = cur + next cur = next next = tmp } } Versus

Multiple Suspend Points sequence { yield(1) // first Fibonacci number var cur = 1 var next = 1 while (true) { yield(next) // next Fibonacci number val tmp = cur + next cur = next next = tmp } }

Why use coroutines?

Why use coroutines? • Another tool for writing good code • Two ways to use tool: • Code Structure • Concurrency

https://www.flickr.com/photos/117693452@N04/12547460924

https://www.maxpixel.net/Lana-Frame-Threads-Thread-Handmade-Weaving-3019254

Blocking Functions fun main() { print(calculateMeaningOfLife()) } fun calculateMeaningOfLife(): Int { // Calculates for 7.5 million years, then... return 42 }

Non-Blocking Function suspend fun calculateMeaningOfLife(): Int { delay(7.5 million years) return 42 }

Blocking vs. Nonblocking Blocking Blocked During I/O Non-Blocking Waiting During I/O Doing other work

Two Tasks, One Thread suspend fun task(name: String, delay: Long) { joinAll( async { doSomething("First", 10) }, async { doSomething("Second", 5) } ) } suspend fun doSomething(name: String, delay: Long) { println("$name START (${Thread.currentThread().name})") delay(delay) println("$name END (${Thread.currentThread().name})") } First START (main) Second START (main) Second END (main) First END (main)

Threads == preemptive multitasking Coroutines == cooperative multitasking

Callback Hell requestRandomUrl { url -> downloadImage(url) { image -> displayImage(image) } } myScope.launch { val url = requestRandomUrl() val image = downloadImage(url) displayImage(image) } Vs

Why use coroutines? • Concurrency • Coroutines *are* like light-weight threads! • …In any language! • Code Structure • Coroutines enable simpler code

Kotlin Coroutines

kotlin.coroutines (stdlib) kotlinx.coroutines (library)

kotlin.coroutines (stdlib) kotlinx.coroutines (library)

Stdlib Basics • Suspending functions • A way to start suspending functions • Contexts

Suspend Keyword

Start Suspending Functions suspend fun mySuspendingFunction() fun (suspend () -> T).startCoroutine(completion: Continuation) fun main() { ::mySuspendingFunction.startCoroutine( Continuation(EmptyCoroutineContext) { } ) }

Coroutine Context • Store useful info about coroutine • Dispatcher • Job • Debug info

Coroutine Library

myScope.launch { val image = downloadImage() displayImage(image) } suspend fun downloadImage() = withContext(Dispatchers.IO) { … } fun displayImage(image: Image)

myScope.launch { val image = downloadImage() displayImage(image) } suspend fun downloadImage() = withContext(Dispatchers.IO) { … } fun displayImage(image: Image)

myScope.launch { val image = downloadImage() displayImage(image) } suspend fun downloadImage() = withContext(Dispatchers.IO) { … } fun displayImage(image: Image)

myScope.launch { val image = downloadImage() displayImage(image) } suspend fun downloadImage() = withContext(Dispatchers.IO) { … } fun displayImage(image: Image)

Review • Coroutines are suspending functions • Suspending functions are useful for concurrency • Kotlin stdlib provides coroutine support • Kotlin coroutine library adds practical functions for coroutines

More Info • Longer Talk: https://youtu.be/Axq8LdQqQGQ • Links: github.com/Kotlin/kotlinx.coroutines/#documentation • Roman Elizarov: medium.com/@elizarov • Android + Coroutines: medium.com/@objcode • Structured concurrency: vorpus.org/blog/notes-on-structured- concurrency-or-go-statement-considered-harmful/

@danlew42