Vortrag bei der Parallel 2019 in Heidelberg

1. 11
Nebenläufigkeit
mit Kotlins Koroutinen
Jörn Dinkla, para//el 2019

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 ?

6. 6
2004 2007 20192001 2010 2013 2016
Java 9
Reactive
2017
Java 7
Fork/Join
2011
Java 8
Streams
CmplFut
2014
Java 5
2004
Nebenläufigkeit
Java 1
1995
C++ 11
thread
2011
C++ 14
mutex
2014
C++ 17
par STL
2017
Kotlin
1.0
2016
Kotlin
1.3
2018

7. 7© https://www.flickr.com/photos/dougtone/
Kotlin

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

11. Warum Kotlin?
11
https://pusher.com/state-of-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

13. Kotlin-Trick #1: “extension function”
13
String!

14. Kotlin-Trick #2: Funktion als letzter Parameter
14

15. Kotlin-Trick #3: “lambda with receiver”
15https://kotlinlang.org/docs/reference/lambdas.html#function-literals-with-receiver
Interne
DSL

16. Hello World mit Koroutinen
16

17. Hello World mit Koroutinen
17
●
○ Startet
○ Wartet auf alle Koroutinen
●
○ Startet Koroutine
●
○ Analog

18. 18
Beispielanwendung

19. Verzögerter Web-Server
GET-Request …
http://localhost:9090/${MS}/${URI}
… wartet MS Millisekunden und liefert die Seite URI zurück.
Beispiel:
http://localhost:9090/1500/https://www.parallelcon.de/
19

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

24. 24
Utils
Java11
HttpClient

25. Thread-Pools
● Statt immer neue Threads zu erstellen
● Menge von wartenden Threads bereit halten
●
● Verschiedene Arten
○ ,
○
○
25

26. Thread-Pool in Kotlin
26

27. Performance-Test
27
● nginx in Docker-Container [Port 8080]
● Beispielanwendung [Port 9090]
● loadtest (node/npm)
https://www.npmjs.com/package/loadtest

28. Performance des Thread-Pools
28
Zu wenig
Threads

29. Arten der Auslastung
29
● Computation bound, CPU-bound
○ Prozessor 100% ausgelastet
● IO bound
○ Latency bound
■ Warten auf die Daten
○ Memory bound
■ Bandbreite zum Speicher ausgelastet

30. Optimale Größe des Thread-Pools
30

31. Latenz ist der limitierende Faktor
31

32. Auslastung Thread-Diagramm
32
Web-Server [Main-Thread]
Handler [Thread] Handler [Thread]
F J
Start Ende
F J
Nginx NginxWartet Wartet

33. 33
To block or not to block ...

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:

37. Asynchroner GET-Aufruf
37
Chaining

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!

39. https://blog.jetbrains.com/kotlin/2018/10/kotlin-1-3/

40. Was sind Koroutinen?
40
Threads sind leichtgewichtige Prozesse.
Was sind Koroutinen? Leichtgewichtige Threads?
Zur Beantwortung dieser Frage weitere Grundlagen
erforderlich.

41. Hello World Revisited:
41
● Letzter Parameter ist Lambda mit Receiver
● Was ist ?

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

43. Refactoring:
43

44. Koroutinen-Builder:
44
● erstellt einen
● cancel()
● join()

45. Koroutinen-Builder:
45
● erstellt ein

46. Refactoring:
46

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

49. 49

50. 50

51. 51
●
○ CPU-Bound: Anzahl der Kerne inkl. Hyper-Threading
●
○ max(64, #CPUs),
●
○ Single-Thread für UI

52. 52
Wie es funktioniert ...

53. Continuation-Passing-Style (CPS)
53
● Jede “suspending”-Funktion ...
○ Erhält eine
○ “Callback”, der am Ende aufgerufen wird 1991

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

55. Endlicher Automat
55

56. 56

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.

59. Asynchroner verzögerter Web-Server
59

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

62. Server mit Ktor
62

63. CIO-HttpClient
63

64. 64
Modelle der Nebenläufigkeit

65. Ermöglichen neue Nebenläufigkeits-Modelle
65
Alternative Modelle
● Neue Pattern mit Koroutinen
● Message-Passing, CSP
● Aktoren

66. Lazy-Listen mit Generatoren
66

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

68. Beispiel für Channel
68

69. Produzenten
69

70. Aktoren
Kommunikation über Nachrichten
Aktor besteht aus
● Koroutine
● Zustand
● Channel
70

71. 71

72. 72
Fazit

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

75. Weiterführendes
75

76. Kotlin lernen und ausprobieren
Informationen
● https://kotlinlang.org/
Ausprobieren im Browser
● https://play.kotlinlang.org
Koans
● https://play.kotlinlang.org/koans/overview
76

77. Koroutinen
77
● Roman Elizarov’s Blog
○ Team-Lead für Kotlin-Bibliotheken
○ https://medium.com/@elizarov
○ https://www.youtube.com/watch?v=hb0hfHVWCS0
● Dokumentation
○ https://kotlinlang.org/docs/reference/coroutines-overview.html
● Beispiele
○ https://github.com/Kotlin/kotlin-coroutines-examples/tree/master/exam
ples

78. Literatur
78

79. Vielen Dank für Ihre Aufmerksamkeit
79