Das Dokument diskutiert die Herausforderungen und Relevanz von nebenläufiger Programmierung in der modernen Softwareentwicklung, insbesondere vor dem Hintergrund der steigenden Anzahl von Threads und der Multi-Core-Krise. Es werden verschiedene Paradigmen und Ansätze, wie Actor-Modelle und Software Transactional Memory, vorgestellt, um mit den Problemen der nebenläufigen Verarbeitung umzugehen. Abschließend wird betont, dass es wichtig ist, mit diesen Konzepten vertraut zu sein, während kein universeller Lösungsansatz für alle Probleme existiert.

1. Concurrency Paradigmen
Roman Roelofsen
Managing Director (aka Alpha Geek)
Weigle Wilczek GmbH
Twitter: romanroe
Java Forum Stuttgart, 7. Juli 2011

2. Concurrency - Nebenl¨ufigkeit
a
Beispiele f¨r Nebenl¨ufigkeit
u
a
Eine Anwendung erzeugt und startet neue Thread (f¨r
u
Performance, blockierende API, ...)
Die Umgebung erzeugt und startet neue Threads (z.B.
Web-Server)

3. Nebenl¨ufigkeit - Relevanz Heute
a
Programmierer m¨ssen sich zunehmend mit Nebenl¨ufigkeit
u
a
befassen
Anzahl Rich-Web-Client steigt
Browser
Smart Phones
Tablets
... Autos, Fernseher, ...
Steigende Anzahl von Threads auf dem Server
... zwischen denen eine Kommunikation stattfinden muss
Nebenl¨ufigkeit war schon immer schwierig und wichtig
a
... hat aber bisher selten die notwendige Aufmerksamkeit
erhalten

4. Nebenl¨ufigkeit - Relevanz Heute
a

5. Nebenl¨ufigkeit - Relevanz Heute
a
Multi-Core Krise
”The free lunch is over”
CPU Core Leistung stagniert
Anzahl der Cores steigt
Erh¨hter Bedarf von Nebenl¨ufigkeit
o
a
Prozesse
Threads

6. Nebenl¨ufigkeit - Relevanz Heute
a
Multi-Core Krise?
Artikel, Blogs, etc. sprechen von riesigen Problemen
Multi Core Crisis, Software Crisis, ...
Parallelisierungs-Frameworks sind die neuen
”Framework-Stars”
Java: Kilim, Actors Guild, Actor Foundry
Scala: Scala Actors, Lift, Akka
Python: ParallelProcessing
Groovy: GPars

7. Nebenl¨ufigkeit - Relevanz Heute
a
Analyse Web Anwendungen
Web Anwendungen sind oft eine ”Data Processing Pipeline”
zwischen Browser und Datenbank
Jeder HTTP Request wird auf einen Thread ubertragen
¨
Anzahl der Request i.d.R. gr¨ßer als Anzahl CPU Cores
o
Entscheidene Fragen:
HTTP Requests >= Cores?
Besteht die Notwendigkeit, zwischen den Requests zu
kommunizieren/Daten auszutauschen?
Wird mit externen Systemen kommuniziert?
Datenbank
Web Service
...

8. Nebenl¨ufigkeit - Relevanz Heute
a
Analyse Desktop Anwendungen
Swing/SWT GUI Elemente sind single-threaded => Autsch!
Events werden vermehrt parallel ausgef¨hrt werden m¨ssen
u
u
Desktop Anwendungen m¨ssen einen Weg finden, mehere
u
Cores gleichzeitig zu nutzen

9. Nebenl¨ufigkeit - Relevanz Heute
a
Analyse Desktop Anwendungen
Swing/SWT GUI Elemente sind single-threaded => Autsch!
Events werden vermehrt parallel ausgef¨hrt werden m¨ssen
u
u
Desktop Anwendungen m¨ssen einen Weg finden, mehere
u
Cores gleichzeitig zu nutzen
Entscheidene Fragen:
Gibt es Performance Probleme?
K¨nnen die Algorithmen parallelisiert werden?
o
Wird mit externen Systemen kommuniziert?
Datenbank
Web Service
...

10. Nebenl¨ufigkeit - Herrausforderungen
a
Einfach wenn...
Threads zu 100% isoliert laufen
Die Ausf¨hrungsumgebung single-threaded ist
u
Die Anwendung zustandslos ist
Das Ergebnis uninteressant ist (fire-and-forget)

11. Nebenl¨ufigkeit - Herrausforderungen
a
Identity, Value, State und Mutable State werden beim Einsatz
aktueller Programmiertechniken zu oft vermischt1
Definition:
Value: Ein stabiler, sich nicht ver¨ndernder Wert
a
Identity: Eine Entit¨t, der im Laufe der Zeit verschiedene
a
Werte zugeordnet werden
State: Der Wert, den eine Entit¨t zu einem bestimmten
a
Zeitpunkt hat
Mutable State: Wenn eine Entit¨t verschiedene Werte annimmt
a
Ver¨nderbare Zust¨nde sind ein Problem, wenn
a
a
Nebenl¨ufigkeit vorhanden ist
a
1
Diskussionsgrundlage: http://www.clojure.org/state

12. Value/Identity/State - Johns Alter
Beschreibung:
Identity: Das Alter von John McCarthy
Values: Die Zahlen 50, 51, 52, ...
State 1: John McCarthys Alter 1977
State 2: John McCarthys Alter 1978
Mutable State: Definitiv :-)

13. Value/Identity/State - Johns Alter
In Java:
Identity:
int johnsAge;
Values:
50; 51; 52;
State 1: John McCarthys Alter 1977
johnsAge = 50;
State 2: John McCarthys Alter 1978
johnsAge = 51;

14. Value/Identity/State - Johns Alter
Identity:
int johnsAge = 50;
Threads:
Thread 1 { johnsAge = johnsAge + 1; }
Thread 2 { johnsAge = johnsAge + 2; }
Thread 3 { johnsAge = johnsAge + 3; }
Servlet Code
public void doGet(HttpServletRequest req,
HttpServletResponse res) {
render(johnsAge);
render(johnsAge);
render(johnsAge);
}

15. Nebenl¨ufigkeit - Relevanz Heute
a
Neues Beispiel
Geld von Konto A auf Konto B uberweisen
¨

16. Value/Identity/State - Geld uberweisen
¨
Konto-Entit¨ten
a
Konto a = new Konto();
Konto b = new Konto();
Geld uberweisen
¨
Thread {
a.abheben(100);
b.einzahlen(100);
}
Kontostand pr¨fen
u
Thread {
a.getKontostand();
b.getKontostand();
}

17. Value/Identity/State - Geld uberweisen
¨
L¨sungsversuch 1
o
class Konto {
public synchronized void abheben(long betrag) {
...
}
public synchronized void einzahlen(long betrag) {
...
}
}

18. Value/Identity/State - Geld uberweisen
¨
L¨sungsversuch 2
o
synchronized (kontoA) {
synchronized (kontoB) {
kontoA.abheben(100);
kontoB.einzahlen(100);
}
}

19. Value/Identity/State - Arbeit parallelisieren
Java Code
Thread 1, Thread 2, Thread 3

20. Java’s Bordmittel
Java Syntax / API
synchronized
Thread.sleep()
Thread.interrupt()
Thread.join()
Thread.wait()
Thread.notify()
Evaluierung
Sehr low-level
L¨sst sich kaum auf Gesch¨ftlogik ubertragen
a
a
¨
Code l¨sst sich schwer komponieren
a
Geringe Wiederverwendung
Gefahr von Deadlocks

21. Gentlemen: Choose Your Weapons!
Executor
Future/Promise
Actors
STM
Data Flow Concurrency

22. Executor
Java Code
Executor

23. Future/Promise
Bisher waren unsere Threads ”fire-and-forget”
Das Ergebnis wurde nicht verarbeitet
Doch wieder Thread.join()? (Igitt!!)

24. Future/Promise
Java Code
Future

25. Actors
Message-passing Concurrency
Bekannt durch Erlang Programmiersprache
Kein ”Shared State”
Actors kommunizieren uber Messages
¨
Asynchron & non-blocking
Reactive
Actors senden selbstst¨ndig Messages
a
Actors k¨nnen neue Actors erzeugen
o
Actors bestimmen selber ihr Verhalten beim Empfang

26. Actors
Jeder Actor hat seinen eigenen ”Lebensraum”
Actor ⇐⇒ Thread, oder
Thread Pool
Mailbox
Empfangene Nachrichten werden in der Mailbox gespeichert
Sequentielle Abarbeitung (wie single-threaded)
Actor entscheidet selber, wann Nachrichten aus der Mailbox
verarbeitet werden
Implementierungen
Scala Actors (Teil der Scala Distribution)
Akka (Scala & Java)
Kilim (Java)

27. Actors
Scala Code
Actors1 Actors2 Actors3

28. Software Transactional Memory
Software Transactional Memory (STM)
Der Speicher (Heap/Stack) wird wie eine Datenbank
behandelt
ACI(kein D)
Atomar: Sequenz von Daten-Operationen wird entweder ganz
oder gar nicht ausgef¨hrt
u
Konsistent: Eine Sequenz von Daten-Operationen hinterl¨sst
a
nach Beendigung einen konsistenten Datenzustand
Isoliert: Nebenl¨ufige Daten-Operationen beeinflussen sich
a
nicht gegenseitig

29. Software Transactional Memory
Transaktionsklammer n¨tig
o
Begin, Commit, Rollback
Verschachtelungen sind m¨glich (Yiepiee!)
o
Transaktionen werden bei Kollisionen wiederholt
Transaktionen d¨rfen keine Seiteneffekte beinhalten!
u
Implementierungen
Multiverse (Java)
Scala STM
Elementarer Bestandteil der Sprache Clojure

30. Clojure
”Lisp f¨r die Massen”
u
L¨uft auf der JVM
a
Interoperabilit¨t mit Java
a
Variablen k¨nnen ihren Wert nur im Rahmen des STM
o
Systems ver¨ndern
a

31. Clojure - ”Hello John!”
(ns hello-john)
(def hello "Hello")
(defn say-hello [firstname]
(println hello firstname "!"))
(say-hello "John")
>> Hello John !

32. Software Transactional Memory
Clojure Code
stm1 stm2 stm3

33. DataFlow Concurrency
DataFlow Variablen
Eher deklarativ
Nebenl¨ufigkeit und sequentieller Code wird elegant vermischt
a
Der Datenfluss (Abh¨ngigkeiten) wird zwischen Variablen
a
definiert
Deterministisch
3 einfache Operationen
Create - DataFlow Variable erstellen
Wait - Warten, dass die Variable einen Wert erh¨lt
a
Bind - Der Variable einen Wert zuweisen

34. DataFlow Concurrency
Beispiel Akka Framework
import akka.dataflow.DataFlow._
val x, y, z = new DataFlowVariable[Int]
thread {
z << x() + y()
println("z = " + z())
}
thread { x << 40 }
thread { y << 2 }

35. Fazit
Jeder sollte mit den vorgestellten Konzepten vertraut sein
Eine konkrete Implementierung kann ihm Rahmen eines
Projektes evaluiert und gelernt werden
Es eilt nicht...
... sollte jedoch auch nicht ignoriert werden
Es gibt kein ”Silver Bullet”
Jedes vorgestellte Konzept hat Vor- und Nachteile
Nicht jedes Konzept ist f¨r jedes Problem geeignet
u

36. Durchstarten mit Scala

37. Wir stellen ein!
Wir suchen f¨hige Java/Scala/Clojure Entwickler
a
Wir bieten eine gesunde Mischung aus
Programmierer
Berater
Kicker-Profi
Bitte bei mir melden!
roelofsen@weiglewilczek.com

38. Fragen?