2. ● Nebenläufigkeit kann kompliziert sein
● Kotlins Ansatz:
○ Koroutinen
● Kotlin ist relativ neue Sprache
○ Pragmatisch
○ Besser als Java
○ Schneller und einfacher als Scala
Einleitung
2
3. Jörn Dinkla
3
Software-Entwickler und Berater
● JVM (z. B. Kotlin, Clojure, Java), React, C++
● Konferenzen & Artikel
● GPU-Computing, Machine Learning
jdinkla@thoughtworks.com
http://www.dinkla.net
Folien: https://www.slideshare.net/dinkla
Code: https://github.com/jdinkla/parallel2019-kotlins-koroutinen
4. 4
“A community of passionate individuals
whose purpose is to revolutionize
software design, creation and delivery,
while advocating for positive social change.”
We are
hiring ...
5. Fragen an das Publikum
5
Sprachen
● JVM vs. C++ vs. ?
Nebenläufigkeit
● Erfahrung mit Threads oder Futures ?
8. Kotlin
8
● Interoperabel mit Java
● Objektorientiert
○ Klassen, Null-sichere Typen
● Funktional
○ Higher-Order-Funktionen, Lambdas
● Ausdrucksstark
○ DSLs und Builder-Pattern
○ Koroutinen als DSL implementiert
9. Multi-Plattform
9
● Kotlin for JVM
● Kotlin for Android
● Kotlin JavaScript
● Kotlin Native
○ iOS, Android
○ MacOS, Linux
○ WebAssembly
https://twitter.com/DCKotlin/status/1049279123208773632
10. Bekannte Benutzer von Kotlin
10
● First-class support for Android
● Gradle hat Kotlin-DSL
● ca. 25% der Top500-Apps im Android-Store
○ https://www.appbrain.com/stats/libraries/details/kotlin/kotlin
12. Koroutinen in Kotlin
12
● Ziel
○ Minimale Änderung der Sprache
○ Delegation in Bibliotheken
● Vorbild
○ Java-Collections im Kotlin-SDK
○ Nur Erweiterung des Java-SDKs
○ Keine eigenen Klassen hinzugefügt
20. Algorithmus
Wiederhole
1. Falls neuer Request auf Port P
a. Lies MS und URI aus Eingabe
b. Warte MS
c. Hole Seite von URI
d. Schreibe diese in Ausgabe
Frage: Wenn Wartezeit sehr lang, ist Programm blockiert?
20
21. Prozess im Betriebssystem
21
● Verwaltung von OS-Ressourcen
○ Speicher
○ IO-Deskriptoren
Berühmtes Beispiel: Unix-Pipes aus 70ern
Bild: https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/images/Chapter4/4_01_ThreadDiagram.jpg
22. Thread im Betriebssystem
● Prozess: 1..* Threads
● Teilen sich Ressourcen
● Gemeinsamer Adressraum
● Parallelität innerhalb Prozess
Ein Thread ist ein leichtgewichtiger Prozess.
22Bild: https://www.cs.uic.edu/~jbell/CourseNotes/OperatingSystems/images/Chapter4/4_01_ThreadDiagram.jpg
23. Thread in JVM
23
● Java entspricht OS-Thread
● OS macht Scheduling
● 1 Thread benötigt ca. 2MB an Speicher
● JVM hat eigene Threads
○ Z. B. Garbage Collection
http://blog.jamesdbloom.com/JVMInternals.html
34. Alle Räder stehen still, ...
34
● Blockierender IO:
○ Thread wartet bis Ergebnis zurückgeliefert wird
○ Thread “blockiert”
● Pool mit k Threads und k blockierenden Threads
○ Wartet nur noch
○ CPU-Auslastung sinkt
35. Lösung: Asynchronität
35
● Rufe Funktion nebenläufig auf
○ In der Zwischenzeit erledige andere Dinge
● Lösungsansätze
○ Callbacks
○ Futures, Promises, Deferred
○ Streams
○ Reaktive Programmierung: Observables, Flux
○ Koroutinen
36. Future, Promises und Deferred
36
● Ergebnis kommt zu späterem Zeitpunkt
● ist Interface seit Java 5
○ Viele Implementierungen
○ in Java 8
● Beispiel:
38. Nachteile
38
● Invasive Syntax
○ Funktions-Signaturen ändern sich
● Chaining
○ Erzeugt zwei Ebenen
○ Ändert Code stark
○ Nicht einheitlich über Bibliotheken hinweg
Future sind nicht die Lösung!
40. Was sind Koroutinen?
40
Threads sind leichtgewichtige Prozesse.
Was sind Koroutinen? Leichtgewichtige Threads?
Zur Beantwortung dieser Frage weitere Grundlagen
erforderlich.
42. Was ist ?
42
● Einziges neues Keyword
● Unterbrechbare Funktion oder Lambda
○ Aufrufbar nur von unterbrechbarer Funktion oder
Koroutine
● Bei “suspension points” gibt der Koroutinen-Dispatcher
die Kontrolle an andere Koroutinen
47. Structured Concurrency mit
47
● Platz für Extensionsfunktionen
○ Z. B. die Koroutinen-Builder
● Jeder Builder erstellt neuen Scope mit neuer Job-Instanz
○ Koroutinen bilden eine Hierarchie
○ Flexibel: z. B.
● Builder für “parallel decomposition”
● Hat einen
48. CoroutineContext
48
● Hierarchie von Koroutinen
● Cancel-ability
○ Kooperation für Canceln notwendig mit
● Exception-Handling
○ Für ’s und ’s unterschiedlich
● …
○ Ruft block mit Kontext auf, suspended bis fertig
● Dispatcher und Thread-Pool
54. Implementierung
54
● Jede “suspending”-Funktion ...
○ wird in endlichen Automaten transformiert
■ Zustände: Anfang und “suspension points”
https://github.com/Kotlin/KEEP/blob/master/proposals/coroutines.md
Kotlin Evolution and Enhancement Process
57. Zusammenfassung: Koroutinen-Architektur
● Netzwerk von unterbrechbaren Funktionen
● Merken sich Zustand und Wiederaufsetzpunkte
● Bei “Suspension points” kommt Dispatcher ins Spiel
● bestimmt Thread aus Pool und
Koroutine
57
58. Threads sind leichtgewichtige Prozesse.
Koroutinen sind sehr leichtgewichtige Threads?
Auch überrascht?
58
Koroutinen sind eher ein raffinierter Trick ...
… und haben andere Eigenschaften als Threads.
60. Wie mit Koroutinen entwickeln?
60
Pattern und “Best practices”:
● Müssen noch für die Koroutinen entwickelt werden
● Sind noch nicht endgültig
Hoffentlich in der nahen Zukunft:
● Bibliotheken unterstützen die Koroutinen nativ
● Keine (Umwandlung von) CompletableFutures mehr
61. Ktor
61
● Framework für asynchrone Services
● Benutzt Koroutinen
● Asynchroner IO als Default
● Server und Clients
● DSL für Routes
● Flexibel, vielseitige “Plug-In”-Möglichkeiten
https://ktor.io/
https://github.com/ktorio/ktor
67. Channels
67
● CPS, Message-Passing und Aktoren
● Channel zum Lesen und Schreiben
○ send() ist suspending
● Verschiedene Arten
○ Buffer-Channel, z. B. mit Backpressure
○ Rendezvous-Channel
■ Suspend des Senders, bis retrieved()
73. Fazit
73
● Alles bleibt beim alten, bis auf Schlüsselwort
Daher
● Sequentiell per Default
● Nebenläufig explizit durch angegeben
● Minimal-invasive Syntax
● Gute Integration in bisherigen Code
● Funktionen können normal verwendet werden
74. Fazit
74
Koroutinen sind keine leichtgewichtige Threads.
● Koroutinen sind eigenständiges Modell der
Nebenläufigkeit
● Ermöglichen Modelle jenseits von Threads und Futures
● Können zu modularen, wartbaren und einfach zu
verstehenden Code führen
● Benötigen Einarbeitungszeit und Experimente
● Viele Bibliotheken müssen noch suspend-able werden