Roman Elizarov, profile picture
Uploaded byRoman Elizarov
PDF, PPTX5,281 views

Kotlin Coroutines in Practice @ KotlinConf 2018

The document discusses Kotlin coroutines, highlighting their lightweight nature similar to threads and practical usage for tasks such as downloading content. It emphasizes structured concurrency for managing references and downloading processes, addressing concerns about shared mutable state and potential crashes. The document also describes various patterns for handling worker threads and using channels for efficient communication in concurrent programming.

Download as PDF, PPTX
1 / 128
2 / 128
3 / 128
4 / 128
5 / 128
6 / 128
7 / 128
8 / 128
9 / 128
10 / 128
11 / 128
12 / 128
13 / 128
14 / 128
Most read
15 / 128
16 / 128
17 / 128
18 / 128
19 / 128
20 / 128
21 / 128
22 / 128
23 / 128
24 / 128
25 / 128
26 / 128
Most read
27 / 128
28 / 128
29 / 128
30 / 128
31 / 128
32 / 128
33 / 128
34 / 128
35 / 128
36 / 128
37 / 128
38 / 128
39 / 128
40 / 128
41 / 128
42 / 128
43 / 128
44 / 128
45 / 128
46 / 128
47 / 128
48 / 128
49 / 128
50 / 128
51 / 128
52 / 128
53 / 128
54 / 128
55 / 128
56 / 128
57 / 128
58 / 128
59 / 128
60 / 128
61 / 128
62 / 128
63 / 128
64 / 128
65 / 128
66 / 128
67 / 128
68 / 128
69 / 128
70 / 128
71 / 128
72 / 128
73 / 128
74 / 128
75 / 128
76 / 128
77 / 128
78 / 128
79 / 128
80 / 128
81 / 128
82 / 128
83 / 128
84 / 128
85 / 128
86 / 128
87 / 128
88 / 128
89 / 128
90 / 128
Most read
91 / 128
92 / 128
93 / 128
94 / 128
95 / 128
96 / 128
97 / 128
98 / 128
99 / 128
100 / 128
101 / 128
102 / 128
103 / 128
104 / 128
105 / 128
106 / 128
107 / 128
108 / 128
109 / 128
110 / 128
111 / 128
112 / 128
113 / 128
114 / 128
115 / 128
116 / 128
117 / 128
118 / 128
119 / 128
120 / 128
121 / 128
122 / 128
123 / 128
124 / 128
125 / 128
126 / 128
127 / 128
128 / 128
elizarov@ Roman Elizarov Kotlin Coroutines in Practice @relizarov
Coroutines recap
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
suspend fun main() { val jobs = List(100_000) { GlobalScope.launch { delay(5000) print(".") } } jobs.forEach { it.join() } } 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
Quantity
Quantity → Quality
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 fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() … } }
References Locations Contents resolve download fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() val content = downloadContent(location) processContent(ref, content) } }
References Locations Contents resolve download suspend fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() val content = downloadContent(location) processContent(ref, content) } }
References Locations Contents resolve download suspend fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() val content = downloadContent(location) processContent(ref, content) } } Sequential
References Locations Contents resolve download fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() val content = downloadContent(location) processContent(ref, content) } } Parallel
References Locations Contents resolve download fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() GlobalScope.launch { val content = downloadContent(location) processContent(ref, content) } } } Parallel
fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() GlobalScope.launch { val content = downloadContent(location) processContent(ref, content) } } } Coroutines are cheap! What could go wrong?
fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() GlobalScope.launch { val content = downloadContent(location) processContent(ref, content) } } } ref1 location1 Launch download ref2 location2 Launch download ref3 Crash! Crash!
ref1 location1 Launch download ref2 location2 Launch download ref3 Crash! Crash! Leak! fun processReferences(refs: List<Reference>) { for (ref in refs) { val location = ref.resolveLocation() GlobalScope.launch { val content = downloadContent(location) processContent(ref, content) } } }
Structured concurrency
fun processReferences(refs: List<Reference>)
suspend fun processReferences(refs: List<Reference>)
suspend fun processReferences(refs: List<Reference>) = coroutineScope { … }
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() GlobalScope.launch { val content = downloadContent(location) processContent(ref, content) } } }
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } }
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } } Child
Crash? suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } }
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } } Crash?
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } } Crash? cancels
Crash? cancels Waits for completion suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } }
suspend fun processReferences(refs: List<Reference>) = coroutineScope { for (ref in refs) { val location = ref.resolveLocation() launch { val content = downloadContent(location) processContent(ref, content) } } } Never leaks jobs
The state
References Contents Download process
Reference 1 Content Reference 2 Location Download process State
class Downloader { }
class Downloader { private val requested = mutableSetOf<Location>() }
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() … } }
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } } }
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } } Concurrent
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } } Concurrent
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } } Shared mutable state
class Downloader { private val requested = mutableSetOf<Location>() fun downloadReference(ref: Reference) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } } Shared mutable state Needs Synchronization Shared + Mutable =
Shared Mutable State Share by Communicating
Synchronization Primitives Communication Primitives
classes coroutines
launch { val requested = mutableSetOf<Location>() … } Does not share mutable state
launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
Channel References Downloader
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { … }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { … }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { … }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { … } Convention
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { // schedule download } // ... wait for result ... processContent(ref, content) } }
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { launch { … } } // ... wait for result ... processContent(ref, content) } } Coroutines are cheap! What could go wrong?
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { launch { … } } // ... wait for result ... processContent(ref, content) } } Child
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { launch { … } } // ... wait for result ... processContent(ref, content) } } Coroutines are cheap! But the work they do…
Limiting concurrency
Worker 1 Worker 2 Worker 3 Worker N Worker pool … References Downloader references locations
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, locations: SendChannel<Location> )
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, locations: SendChannel<Location> ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { locations.send(location) } } }
fun CoroutineScope.worker( locations: ReceiveChannel<Location> )
fun CoroutineScope.worker( locations: ReceiveChannel<Location> )
fun CoroutineScope.worker( locations: ReceiveChannel<Location> ) = launch { for (loc in locations) { val content = downloadContent(loc) processContent(ref, content) } }
fun CoroutineScope.worker( locations: ReceiveChannel<Location> ) = launch { for (loc in locations) { val content = downloadContent(loc) processContent(ref, content) } } Fan-out
fun CoroutineScope.worker( locations: ReceiveChannel<Location> ) = launch { for (loc in locations) { val content = downloadContent(location) processContent(ref, content) } }
fun CoroutineScope.worker( locations: ReceiveChannel<Location> ) = launch { for (loc in locations) { val content = downloadContent(loc) processContent(ref, content) } }
fun CoroutineScope.worker( locations: ReceiveChannel<Location> ) = launch { for (loc in locations) { val content = downloadContent(loc) processContent(ref, content) } }
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)
data class LocContent(val loc: Location, val content: Content) fun CoroutineScope.worker( locations: ReceiveChannel<Location>, contents: SendChannel<LocContent> )
data class LocContent(val loc: Location, val content: Content) fun CoroutineScope.worker( locations: ReceiveChannel<Location>, contents: SendChannel<LocContent> ) = launch { for (loc in locations) { val content = downloadContent(loc) contents.send(LocContent(loc, content)) } }
Worker 1 Worker 2 Worker 3 Worker N … References Downloader locations contents
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, locations: SendChannel<Location>, contents: ReceiveChannel<LocContent> )
fun CoroutineScope.downloader( references: ReceiveChannel<Reference>, locations: SendChannel<Location>, contents: ReceiveChannel<LocContent> ) = launch { val requested = mutableSetOf<Location>() for (ref in references) { val location = ref.resolveLocation() if (requested.add(location)) { locations.send(location) } } } Hmm….
Select
select { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> … } }
select { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> … } }
select<Unit> { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> … } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() … }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> val loc = ref.resolveLocation() … } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> val loc = ref.resolveLocation() val refs = requested[loc] … } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> val loc = ref.resolveLocation() val refs = requested[loc] if (refs == null) { requested[loc] = mutableListOf(ref) locations.send(loc) } } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> val loc = ref.resolveLocation() val refs = requested[loc] if (refs == null) { requested[loc] = mutableListOf(ref) locations.send(loc) } else { refs.add(ref) } } contents.onReceive { (loc, content) -> … } } } }
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> val loc = ref.resolveLocation() val refs = requested[loc] if (refs == null) { requested[loc] = mutableListOf(ref) locations.send(loc) } else { refs.add(ref) } } contents.onReceive { (loc, content) -> … } } } } No concurrency No synchronization
launch { val requested = mutableMapOf<Location, MutableList<Reference>>() while (true) { select<Unit> { references.onReceive { ref -> … } contents.onReceive { (loc, content) -> val refs = requested.remove(loc)!! for (ref in refs) { processContent(ref, content) } } } } }
Putting it all together
Worker 1 Worker 2 Worker 3 Worker N … References Downloader locations contents references
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> )
fun CoroutineScope.processReferences( references: ReceiveChannel<Reference> ) { val locations = Channel<Location>() val contents = Channel<LocContent>() repeat(N_WORKERS) { worker(locations, contents) } downloader(references, locations, contents) }
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
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(…)
Root CoroutineScope
class SomethingWithLifecycle { }
class SomethingWithLifecycle : CoroutineScope { }
class SomethingWithLifecycle : CoroutineScope { override val coroutineContext: CoroutineContext get() = … }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() override val coroutineContext: CoroutineContext get() = … }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() fun dispose() { … } override val coroutineContext: CoroutineContext get() = … }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() fun close() { … } override val coroutineContext: CoroutineContext get() = … }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() fun close() { job.cancel() } override val coroutineContext: CoroutineContext get() = … }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() fun close() { job.cancel() } override val coroutineContext: CoroutineContext get() = job }
class SomethingWithLifecycle : CoroutineScope { private val job = Job() fun close() { job.cancel() } override val coroutineContext: CoroutineContext get() = job + Dispatchers.Main }
class SomethingWithLifecycle : CoroutineScope { … override val coroutineContext: CoroutineContext get() = job + Dispatchers.Main fun doSomething() { } }
class SomethingWithLifecycle : CoroutineScope { … override val coroutineContext: CoroutineContext get() = job + Dispatchers.Main fun doSomething() { launch { … } } }
class SomethingWithLifecycle : CoroutineScope { … override val coroutineContext: CoroutineContext get() = job + Dispatchers.Main fun doSomething() { processReferences(references) } } Never leak any coroutines
suspend vs scope
suspend fun downloadContent(location: Location): Content
suspend fun downloadContent(location: Location): Content Does something long & waits for it to complete without blocking
suspend fun downloadContent(location: Location): Content fun CoroutineScope.processReferences(…)
suspend fun downloadContent(location: Location): Content fun CoroutineScope.processReferences(…) Launches new coroutines & quickly returns, does not wait for them
Takeaway
Coroutines are like light-weight threads
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

More Related Content

PDF
Introduction to Coroutines @ KotlinConf 2017
byRoman Elizarov
 
PDF
Deep dive into Coroutines on JVM @ KotlinConf 2017
byRoman Elizarov
 
PDF
Kotlin Coroutines Reloaded
byRoman Elizarov
 
PDF
Introduction to Kotlin coroutines
byRoman Elizarov
 
PDF
Introduction to kotlin coroutines
byNAVER Engineering
 
PDF
Kotlin Coroutines. Flow is coming
byKirill Rozov
 
PDF
Spring Framework - AOP
byDzmitry Naskou
 
PDF
Coroutines in Kotlin. In-depth review
byDmytro Zaitsev
 
Introduction to Coroutines @ KotlinConf 2017
byRoman Elizarov
 
Deep dive into Coroutines on JVM @ KotlinConf 2017
byRoman Elizarov
 
Kotlin Coroutines Reloaded
byRoman Elizarov
 
Introduction to Kotlin coroutines
byRoman Elizarov
 
Introduction to kotlin coroutines
byNAVER Engineering
 
Kotlin Coroutines. Flow is coming
byKirill Rozov
 
Spring Framework - AOP
byDzmitry Naskou
 
Coroutines in Kotlin. In-depth review
byDmytro Zaitsev
 

What's hot

PDF
Goroutines and Channels in practice
byGuilherme Garnier
 
PDF
Asynchronous JavaScript Programming with Callbacks & Promises
byHùng Nguyễn Huy
 
PPTX
Practical QML - Key Navigation, Dynamic Language and Theme Change
byBurkhard Stubert
 
PPTX
Spring Boot
byJiayun Zhou
 
PDF
Declarative UIs with Jetpack Compose
byRamon Ribeiro Rabello
 
PDF
Golang Channels
byJoris Bonnefoy
 
PPTX
Optional in Java 8
byRichard Walker
 
PDF
RxJS Operators - Real World Use Cases (FULL VERSION)
byTracy Lee
 
PDF
Angular js routing options
byNir Kaufman
 
PDF
Monadic Java
byMario Fusco
 
PDF
jQuery Essentials
byMarc Grabanski
 
PPTX
Webpack Introduction
byAnjali Chawla
 
PDF
Introduction to Celery
byChathuranga Bandara
 
PDF
Coroutines for Kotlin Multiplatform in Practise
byChristian Melchior
 
PPTX
10 Problems with your RMAN backup script
byYury Velikanov
 
PPT
Hibernate
bySunil OS
 
PDF
Redux Sagas - React Alicante
byIgnacio Martín
 
PPTX
Vue js for beginner
byChandrasekar G
 
PPTX
Best practices for ansible
byGeorge Shuklin
 
PDF
Aynchronous Processing in Kamailio Configuration File
byDaniel-Constantin Mierla
 
Goroutines and Channels in practice
byGuilherme Garnier
 
Asynchronous JavaScript Programming with Callbacks & Promises
byHùng Nguyễn Huy
 
Practical QML - Key Navigation, Dynamic Language and Theme Change
byBurkhard Stubert
 
Spring Boot
byJiayun Zhou
 
Declarative UIs with Jetpack Compose
byRamon Ribeiro Rabello
 
Golang Channels
byJoris Bonnefoy
 
Optional in Java 8
byRichard Walker
 
RxJS Operators - Real World Use Cases (FULL VERSION)
byTracy Lee
 
Angular js routing options
byNir Kaufman
 
Monadic Java
byMario Fusco
 
jQuery Essentials
byMarc Grabanski
 
Webpack Introduction
byAnjali Chawla
 
Introduction to Celery
byChathuranga Bandara
 
Coroutines for Kotlin Multiplatform in Practise
byChristian Melchior
 
10 Problems with your RMAN backup script
byYury Velikanov
 
Hibernate
bySunil OS
 
Redux Sagas - React Alicante
byIgnacio Martín
 
Vue js for beginner
byChandrasekar G
 
Best practices for ansible
byGeorge Shuklin
 
Aynchronous Processing in Kamailio Configuration File
byDaniel-Constantin Mierla
 

Similar to Kotlin Coroutines in Practice @ KotlinConf 2018

PDF
Structured concurrency with Kotlin Coroutines
byVadims Savjolovs
 
PPTX
Coroutines talk ppt
byShahroz Khan
 
PDF
Kotlin coroutine - the next step for RxJava developer?
byArtur Latoszewski
 
PDF
Coroutines and RxJava - An Asynchronicity Comparison
byManuel Vicente Vivo
 
PDF
Programação assíncrona utilizando Coroutines
byDiego Gonçalves Santos
 
PDF
Improving app performance with Kotlin Coroutines
byHassan Abid
 
PDF
Coroutines in Kotlin. UA Mobile 2017.
byUA Mobile
 
PDF
Kotlin from-scratch 3 - coroutines
byFranco Lombardo
 
PDF
TDC2018SP | Trilha Kotlin - Programacao assincrona utilizando Coroutines
bytdc-globalcode
 
PPTX
2019-01-29 - Demystifying Kotlin Coroutines
byEamonn Boyle
 
PPTX
Kotlin coroutines and spring framework
bySunghyouk Bae
 
PDF
Quick Introduction to Kotlin Coroutine for Android Dev
byShuhei Shogen
 
PDF
Lean way write asynchronous code with Kotlin’s coroutines - Ronen Sabag, Gett
byDroidConTLV
 
PDF
Tackling Asynchrony with Kotlin Coroutines
byTech Triveni
 
PDF
Kotlin - Coroutine
bySean Tsai
 
PDF
Should it be routine to use coroutines?
byIon Stefan Brosteanu
 
PDF
Current State of Coroutines
byGuido Pio Mariotti
 
PDF
KOTLIN COROUTINES - PART 1
byBartosz Kozajda
 
PDF
Fabio Collini - Async code on Kotlin: RxJava or/and coroutines - Codemotion M...
byCodemotion
 
PPTX
Design patterns with kotlin
byAlexey Soshin
 
Structured concurrency with Kotlin Coroutines
byVadims Savjolovs
 
Coroutines talk ppt
byShahroz Khan
 
Kotlin coroutine - the next step for RxJava developer?
byArtur Latoszewski
 
Coroutines and RxJava - An Asynchronicity Comparison
byManuel Vicente Vivo
 
Programação assíncrona utilizando Coroutines
byDiego Gonçalves Santos
 
Improving app performance with Kotlin Coroutines
byHassan Abid
 
Coroutines in Kotlin. UA Mobile 2017.
byUA Mobile
 
Kotlin from-scratch 3 - coroutines
byFranco Lombardo
 
TDC2018SP | Trilha Kotlin - Programacao assincrona utilizando Coroutines
bytdc-globalcode
 
2019-01-29 - Demystifying Kotlin Coroutines
byEamonn Boyle
 
Kotlin coroutines and spring framework
bySunghyouk Bae
 
Quick Introduction to Kotlin Coroutine for Android Dev
byShuhei Shogen
 
Lean way write asynchronous code with Kotlin’s coroutines - Ronen Sabag, Gett
byDroidConTLV
 
Tackling Asynchrony with Kotlin Coroutines
byTech Triveni
 
Kotlin - Coroutine
bySean Tsai
 
Should it be routine to use coroutines?
byIon Stefan Brosteanu
 
Current State of Coroutines
byGuido Pio Mariotti
 
KOTLIN COROUTINES - PART 1
byBartosz Kozajda
 
Fabio Collini - Async code on Kotlin: RxJava or/and coroutines - Codemotion M...
byCodemotion
 
Design patterns with kotlin
byAlexey Soshin
 

More from Roman Elizarov

PDF
Fresh Async with Kotlin @ QConSF 2017
byRoman Elizarov
 
PDF
Scale Up with Lock-Free Algorithms @ JavaOne
byRoman Elizarov
 
PDF
Lock-free algorithms for Kotlin Coroutines
byRoman Elizarov
 
PPTX
Non blocking programming and waiting
byRoman Elizarov
 
PDF
ACM ICPC 2016 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
PDF
Многопоточное Программирование - Теория и Практика
byRoman Elizarov
 
PDF
Wait for your fortune without Blocking!
byRoman Elizarov
 
PDF
ACM ICPC 2015 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
PDF
ACM ICPC 2014 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
PDF
Why GC is eating all my CPU?
byRoman Elizarov
 
PDF
Многопоточные Алгоритмы (для BitByte 2014)
byRoman Elizarov
 
PDF
Теоретический минимум для понимания Java Memory Model (для JPoint 2014)
byRoman Elizarov
 
PPTX
DIY Java Profiling
byRoman Elizarov
 
PDF
ACM ICPC 2013 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
PPTX
Java Serialization Facts and Fallacies
byRoman Elizarov
 
PPTX
Millions quotes per second in pure java
byRoman Elizarov
 
PPTX
ACM ICPC 2012 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
PPTX
The theory of concurrent programming for a seasoned programmer
byRoman Elizarov
 
PPTX
Пишем самый быстрый хеш для кэширования данных
byRoman Elizarov
 
Fresh Async with Kotlin @ QConSF 2017
byRoman Elizarov
 
Scale Up with Lock-Free Algorithms @ JavaOne
byRoman Elizarov
 
Lock-free algorithms for Kotlin Coroutines
byRoman Elizarov
 
Non blocking programming and waiting
byRoman Elizarov
 
ACM ICPC 2016 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
Многопоточное Программирование - Теория и Практика
byRoman Elizarov
 
Wait for your fortune without Blocking!
byRoman Elizarov
 
ACM ICPC 2015 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
ACM ICPC 2014 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
Why GC is eating all my CPU?
byRoman Elizarov
 
Многопоточные Алгоритмы (для BitByte 2014)
byRoman Elizarov
 
Теоретический минимум для понимания Java Memory Model (для JPoint 2014)
byRoman Elizarov
 
DIY Java Profiling
byRoman Elizarov
 
ACM ICPC 2013 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
Java Serialization Facts and Fallacies
byRoman Elizarov
 
Millions quotes per second in pure java
byRoman Elizarov
 
ACM ICPC 2012 NEERC (Northeastern European Regional Contest) Problems Review
byRoman Elizarov
 
The theory of concurrent programming for a seasoned programmer
byRoman Elizarov
 
Пишем самый быстрый хеш для кэширования данных
byRoman Elizarov
 

Recently uploaded

PPTX
Artificial Intelligence lecture slides.pptx
bymaimelabernard6
 
PDF
Linux Day Prato 2025: NixOS spiegato ammiocuggino - NixOS for Human Beings
byPeter Bittner
 
PDF
AWS Community Day Indonesia 2025 - Attack the Cloud Before Attackers Do Build...
byMuhammad Yuga Nugraha
 
PDF
Memo No.3006141 dt.25.10.2025- SOP for Grant of Online Change Of Land Use
byRaghu Ram
 
PDF
TrustArc Webinar - Migration to TrustArc: What Your Journey Will Look Like
byTrustArc
 
PPTX
Stop Worrying, Start Wiring: Azure Serverless for the AI Era
byMuralidharan Deenathayalan
 
PDF
From Data Chaos to Copilot Confidence: A Step-by-Step Microsoft 365 Copilot R...
byNikki Chapple
 
PDF
Internet of Things and Big Data as enablers for business digitalization strat...
byRawan Alharbi
 
PDF
ChatGPT Ain't Got $%@& On Me! by Andy Pavlo
byScyllaDB
 
PDF
ClipsField AI - Transform Static Images Into Cinematic Videos in Minutes.pdf
bySOFTTECHHUB
 
PPTX
sustainability_digital_transformation-slidershare.pptx
byAlokGope
 
PDF
Framework for Measuring Semantic Fidelity: Tracking Drift, Tone, and Intent i...
bySemantic Fidelity Lab
 
PPTX
Mosaic: The Agentic AI Video Editing Platform
byDaniel Gimness
 
PDF
RaBitQ, JSON Index, Schema Evolution, What's New in Milvus 2.6
byZilliz
 
PDF
STurbo M.C. Surge Prevention by CCC Company
byRobertWaters35
 
PDF
The State of Adventure Capital - Grant Gregory | Cantos
byRazin Mustafiz
 
PDF
Session 3 - UiPath Coded Agents & MCP Server in Action
byDianaGray10
 
PPTX
Session 6 Specialized AI Associate Series: The GenAI Experience in UiPath Doc...
byDianaGray10
 
PDF
AI-Driven DevOps: How LLMs and Agents Are Changing Software Delivery
byAll Things Open
 
PDF
Energia Nowa and byteLAKE Partner to Develop Intelligent Services for Energy ...
bybyteLAKE
 
Artificial Intelligence lecture slides.pptx
bymaimelabernard6
 
Linux Day Prato 2025: NixOS spiegato ammiocuggino - NixOS for Human Beings
byPeter Bittner
 
AWS Community Day Indonesia 2025 - Attack the Cloud Before Attackers Do Build...
byMuhammad Yuga Nugraha
 
Memo No.3006141 dt.25.10.2025- SOP for Grant of Online Change Of Land Use
byRaghu Ram
 
TrustArc Webinar - Migration to TrustArc: What Your Journey Will Look Like
byTrustArc
 
Stop Worrying, Start Wiring: Azure Serverless for the AI Era
byMuralidharan Deenathayalan
 
From Data Chaos to Copilot Confidence: A Step-by-Step Microsoft 365 Copilot R...
byNikki Chapple
 
Internet of Things and Big Data as enablers for business digitalization strat...
byRawan Alharbi
 
ChatGPT Ain't Got $%@& On Me! by Andy Pavlo
byScyllaDB
 
ClipsField AI - Transform Static Images Into Cinematic Videos in Minutes.pdf
bySOFTTECHHUB
 
sustainability_digital_transformation-slidershare.pptx
byAlokGope
 
Framework for Measuring Semantic Fidelity: Tracking Drift, Tone, and Intent i...
bySemantic Fidelity Lab
 
Mosaic: The Agentic AI Video Editing Platform
byDaniel Gimness
 
RaBitQ, JSON Index, Schema Evolution, What's New in Milvus 2.6
byZilliz
 
STurbo M.C. Surge Prevention by CCC Company
byRobertWaters35
 
The State of Adventure Capital - Grant Gregory | Cantos
byRazin Mustafiz
 
Session 3 - UiPath Coded Agents & MCP Server in Action
byDianaGray10
 
Session 6 Specialized AI Associate Series: The GenAI Experience in UiPath Doc...
byDianaGray10
 
AI-Driven DevOps: How LLMs and Agents Are Changing Software Delivery
byAll Things Open
 
Energia Nowa and byteLAKE Partner to Develop Intelligent Services for Energy ...
bybyteLAKE
 

Kotlin Coroutines in Practice @ KotlinConf 2018