Kotlin Coroutines in Practice @ KotlinConf 2018

elizarov@
Roman Elizarov
Kotlin Coroutines in
Practice
@relizarov

Coroutines are like
light-weight threads

suspend fun main() {
val jobs = List(100_000) {
GlobalScope.launch {
delay(5000)
print(".")
}
}
jobs.forEach { it.join() }
}
Coroutines are like
light-weight threads

A practical challenge
suspend fun downloadContent(location: Location): Content

fun processReferences(refs: List<Reference>)
References

References
fun processReferences(refs: List<Reference>) {
for (ref in refs) {
…
}
}

References Locations
resolve
for (ref in refs) {
val location = ref.resolveLocation()
…
}
}

References Locations Contents
resolve download
for (ref in refs) {
val content = downloadContent(location)
processContent(ref, content)
}
}

resolve download
suspend fun processReferences(refs: List<Reference>) {
for (ref in refs) {
}
}

resolve download
suspend fun processReferences(refs: List<Reference>) {
for (ref in refs) {
}
}
Sequential

resolve download
for (ref in refs) {
}
}
Parallel

resolve download
for (ref in refs) {
}
}
}
Parallel

for (ref in refs) {
}
}
}
Coroutines are cheap! What could go wrong?

for (ref in refs) {
}
}
}
ref1 location1 Launch download
ref3
Crash!
Crash!

ref3
Crash!
Crash! Leak!
for (ref in refs) {
}
}
}

fun processReferences(refs: List<Reference>)

suspend fun processReferences(refs: List<Reference>)

suspend fun processReferences(refs: List<Reference>) =
coroutineScope {
…
}

coroutineScope {
for (ref in refs) {
}
}
}

coroutineScope {
for (ref in refs) {
launch {
}
}
}

coroutineScope {
for (ref in refs) {
launch {
}
}
}
Child

Crash?
coroutineScope {
for (ref in refs) {
launch {
}
}
}

coroutineScope {
for (ref in refs) {
launch {
}
}
}
Crash?

coroutineScope {
for (ref in refs) {
launch {
}
}
}
Crash?
cancels

Crash?
cancels
Waits for completion
coroutineScope {
for (ref in refs) {
launch {
}
}
}

coroutineScope {
for (ref in refs) {
launch {
}
}
}
Never leaks jobs

References Contents
Download process

Reference 1
Content
Reference 2
Location
Download process
State

class Downloader {
private val requested = mutableSetOf<Location>()
}

class Downloader {
fun downloadReference(ref: Reference) {
…
}
}

class Downloader {
if (requested.add(location)) {
// schedule download
}
}
}

class Downloader {
}
// ... wait for result ...
}
}

class Downloader {
}
}
}
Concurrent

class Downloader {
}
}
}
Shared mutable state

class Downloader {
}
}
}
Shared mutable state
Needs Synchronization
Shared + Mutable =

Shared
Mutable State
Share by
Communicating

Synchronization
Primitives
Communication
Primitives

launch {
val requested = mutableSetOf<Location>()
…
}
Does not share mutable state

launch {
for (ref in references) {
}
}
}

fun CoroutineScope.downloader(
references: ReceiveChannel<Reference>,
) =
launch {
…
}

) =
launch {
…
}
Convention

) =
launch {
}
}
}

) =
launch {
launch { … }
}
}
}
Coroutines are cheap! What could go wrong?

) =
launch {
launch { … }
}
}
}
Child

) =
launch {
launch { … }
}
}
}
Coroutines are cheap! But the work they do…

Worker 1
Worker 2
Worker 3
Worker N
Worker pool
…
References
Downloader
references locations

locations: SendChannel<Location>
)

locations: SendChannel<Location>
) =
launch {
locations.send(location)
}
}
}

fun CoroutineScope.worker(
locations: ReceiveChannel<Location>
)

) =
launch {
for (loc in locations) {
val content = downloadContent(loc)
}
}

) =
launch {
}
}
Fan-out

) =
launch {
}
}

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader
Refs ↔ Locs
location &
content

data class LocContent(val loc: Location, val content: Content)

locations: ReceiveChannel<Location>,
contents: SendChannel<LocContent>
)

locations: ReceiveChannel<Location>,
contents: SendChannel<LocContent>
) =
launch {
contents.send(LocContent(loc, content))
}
}

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader
locations
contents

locations: SendChannel<Location>,
contents: ReceiveChannel<LocContent>
)

locations: SendChannel<Location>,
contents: ReceiveChannel<LocContent>
) =
launch {
locations.send(location)
}
}
}
Hmm….

select {
references.onReceive { ref ->
…
}
contents.onReceive { (loc, content) ->
…
}
}

select<Unit> {
…
}
…
}
}

launch {
val requested = mutableMapOf<Location, MutableList<Reference>>()
…
}

launch {
while (true) {
select<Unit> {
references.onReceive { ref -> … }
contents.onReceive { (loc, content) -> … }
}
}
}

launch {
while (true) {
select<Unit> {
val loc = ref.resolveLocation()
…
}
}
}
}

launch {
while (true) {
select<Unit> {
val refs = requested[loc]
…
}
}
}
}

launch {
while (true) {
select<Unit> {
if (refs == null) {
requested[loc] = mutableListOf(ref)
locations.send(loc)
}
}
}
}
}

launch {
while (true) {
select<Unit> {
if (refs == null) {
locations.send(loc)
} else {
refs.add(ref)
}
}
}
}
}

launch {
while (true) {
select<Unit> {
if (refs == null) {
locations.send(loc)
} else {
refs.add(ref)
}
}
}
}
}
No concurrency
No synchronization

launch {
while (true) {
select<Unit> {
references.onReceive { ref -> … }
val refs = requested.remove(loc)!!
for (ref in refs) {
}
}
}
}
}

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader
locations
contents
references

fun CoroutineScope.processReferences(
references: ReceiveChannel<Reference>
)

fun CoroutineScope.processReferences(
references: ReceiveChannel<Reference>
) {
val locations = Channel<Location>()
val contents = Channel<LocContent>()
repeat(N_WORKERS) { worker(locations, contents) }
downloader(references, locations, contents)
}

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader
locations
contents
references
processReferences

Worker 1
Worker 2
Worker 3
Worker N
…
References
Downloader
locations
contents
references
processReferences
Patterns
everywhere Worker pool
Actor

fun CoroutineScope.processReferences(…)

class SomethingWithLifecycle {
}

class SomethingWithLifecycle : CoroutineScope {
}

override val coroutineContext: CoroutineContext
get() = …
}

private val job = Job()
get() = …
}

fun dispose() { … }
get() = …
}

fun close() { … }
get() = …
}

fun close() {
job.cancel()
}
get() = …
}

fun close() {
job.cancel()
}
get() = job
}

fun close() {
job.cancel()
}
get() = job + Dispatchers.Main
}

…
fun doSomething() {
}
}

…
fun doSomething() {
launch { … }
}
}

…
fun doSomething() {
processReferences(references)
}
}
Never leak any coroutines

Does something long &
waits for it to complete without blocking

Launches new coroutines &
quickly returns, does not wait for them

Coroutines are NOT like
threads

Coroutines are NOT like
threads
Rethink the way you
structure your code

Thank you
Any questions?
elizarov@
Roman Elizarov
@relizarov

Kotlin Coroutines in Practice @ KotlinConf 2018

More Related Content

What's hot

Similar to Kotlin Coroutines in Practice @ KotlinConf 2018

More from Roman Elizarov

Recently uploaded

Kotlin Coroutines in Practice @ KotlinConf 2018