Prozesse und Threads - Parallele und verteilte Systeme

Vorlesung 2
Prozesse und Threads
1
P ROZESSE IN S OFTWARESYSTEMEN
• Komplexe Systeme bestehen aus mehreren Programmen,
die gelichzeitig/nebenläufig ausgeführt werden
• Die Ausführung eines Programms wird oft als
sequentieller Prozeß dargestellt werden:
Prozess = Programm in Ausführung
• Prozesse können sich zeitlich überlappen, um . . .
➜ die Nebenläufigkeit der Welt wiederzuspiegeln,
➜ die Ausführung zeitaufwendiger Tasks zu verlagern,
➜ die Kommunikation mit mehreren Partnern zu managen
Nebenläufige Software ist kompliziert und fehleranfällig.
Ein rigoroser, ingenieurmäßiger Entwurfsansatz ist nötig.
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
2
E NTWURF NEBENLÄUFIGER S YSTEME : B EISPIEL
➜ Wir werden heute das Beispiel aus der vorigen Vorlesung “in
Aktion” sehen und beurteilen
➜ Beispiel: Tempomat (cruise control system) entwerfen
➜ Drei Knöpfe: on, off, resume,
➜ Aufgabe: entwickeln ein korrektes, effizientes Java-Programm,
das die nötige Funktionalität liefert
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
3
B EISPIEL : F OR TS .
Cruise Control System (Specification in plain English):
➜ When the car engine is
switched engineOn and the
on button is pressed, the current speed is recorded and
the cruise system is enabled:
it maintains the speed of the
car at the recorded setting
➜ Pressing the brake, accelaMöglicher Fehler: Nach dem Abschalten
rate or off button disables des Motors behält das System den alten
the system; pressing resume Geschwindigkeitswert und beschleuningt
den Wagen selbständig (ohne Fahrer!)
re-enables the system
beim nächsten Einschalten des Motors
Kritische Fragen
➜ Ist das System sicher (safety) ?
➜ Blockiert das System nicht (progress/liveness) ?
➜ Wie sicher kann man sich über die Antworten sein ?
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
4
U NSER M ODELLANSATZ
• Modelle werden als eine Art endlicher Automaten –
Labeled Transition Systems (LTS)
graphisch dargestellt
• Textuell werden sie in einer algebraischen Notation –
Finite State Processes (FSP)
dargestellt
d.h. zusammengefaßt:
➜ LTS – graphische Darstellung als Zustandsübergangsgraph
➜ FSP – textuelle Darstellung als Programm,
mit einer Reihe algebraischer Gesetze
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
5
VON P ROZESSEN ZU T HREADS
Konzepte:
Prozesse – sequentielle
Ausführungseinheiten
⇓
Modelle:
Finite state processes (FSP)
zum Modellieren von Prozessen
als Sequenzen von Aktivitäten
Labelled transition systems (LTS)
zum Analysieren, Veranschaulichen
und Animieren vom Verhalten
⇓
Praxis:
c
2003
BY
Java Threads in Programmen
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
6
M ODELLIERUNG VON P ROZESSEN MIT LTS
Ein Prozeß ist die Ausführung eines sequentiellen Programms
Beispiel. Prozeß SWITCH (Lichtschalter), modelliert als LTS:
➜ Zustände (states): 0, 1.
(i.d.R. Werte der Programmvariablen)
➜ Aktionen (actions): on, off.
0
(i.d.R. Anweisungen/Instruktionen)
➜ Spuren (traces): Aktionssequenzen
on → off → on → off → . . .
on
1
off
Unsere (abstrakte) Sicht: Jeder Prozeß besitzt einen Zustand,
der durch atomare (unteilbare) Aktionen modifiziert wird
Beachte: Graphen werden schnell unübersichtlich, und sind für
maschinelle Bearbeitung wenig geeignet.
Deshalb ist zusätzlich eine textuelle Darstellung nötig.
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
7
FSP (Finite State Processes) – T EXTUELLE DARSTELLUNG
Aktions-Präfix (Def.): x->P ist ein Prozeß, der Aktion x
ausführt und sich dann wie Prozeß P verhält
Rekursive FSP-Darstellung von SWITCH.
on
Prozesse OFF und ON entsprechen
den Zuständen 0 bzw. 1:
0
SWITCH
OFF
ON
= OFF,
= (on -> ON),
= (off -> OFF).
1
off
Durch Substituieren wird unsere FSP-Definition verkürzt:
SWITCH
OFF
= OFF,
= (on -> (off -> OFF)).
... und nochmals substituieren:
SWITCH
c
2003
BY
= (on -> off -> SWITCH).
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
8
LTSA W ERKZEUG :
FPS → LTS → T RACE
LTSA-Werkzeug (Analyzer & Animator) – im Internet:
• erzeugt die LTS-Darstellung eines FSP-Programms
• generiert eine mögliche Trace (Aktionssequenz)
• testet auf Deadlock und Erreichbarkeit der Zustände
Bsp.: Der Animator (LTSA) generiert
eine Trace:
➜ Letzte Aktion hervorgehoben
➜ Nächste mögliche – mit Tick
on
0
1
off
LTSA-Vorführung – in der Übung
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
9
B EISPIEL : E IN E INFACHER G ETRÄNKEAUTOMAT
blue
red
0
1
2
coffee
tea
➜ Zustand mit mehr als einem Übergang bedeutet Auswahl:
• hier Auswahl extern getroffen: Umgebung, Knopfdrücken
• kann auch intern im Prozeß passieren
➜ Es besteht zwar kein semantischer Unterschied zwischen inputund output-Aktionen. Üblicherweise bieten jedoch
input-Aktionen eine Auswahl an, output-Aktionen – keine
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
10
W EITERE KONSTRUKTE IN FSP
Wir werden weitere FSP Konstrukte bei Bedarf in konkreten
Anwendungsfällen kennenlernen, hier übersichtsweise:
Auswahl:
(x -> P | y -> Q)
kann auch nichtdeterministisch sein:
(x -> P | x -> Q)
Bedingung:
(when B x -> P | y -> Q)
wenn B wahr, dann x oder y ,
sonst nur y wählbar
Index:
P = (in[i:0..3] -> out[i] -> P).
akzeptiert einen Wert zwischen 0 und 3
als Eingabe und gibt diesen wieder aus
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
11
B EISPIEL : C OUNTDOWN IN FSP
Der Countdowntimer “tickt” N mal, “beept” und stoppt
COUNTDOWN (N=3)
= (start -> COUNTDOWN[N]),
COUNTDOWN[i:0..N] =
(when(i>0) tick->COUNTDOWN[i-1]
| when(i==0) beep -> STOP
| stop -> STOP).
stop
stop
stop
start
0
c
2003
BY
tick
1
tick
2
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
tick
3
IM
JAVA -U MFELD · VORLESUNG 2
stop
beep
4
5
12
I MPLEMENTIERUNG VON P ROZESSEN
Design
Prozesse: modellieren als
endliche Automaten
mithilfe von FSP/LTS
Threads: implementieren
in Java
Verifikation
Beachte:
• Begriffe Thread und Prozeß werden mit unterschiedlicher
Bedeutung in der Literatur benutzt, manchmal synonym
• Wir werden unterscheiden zwischen:
➜ Prozessen in Modellen (FSP/LTS, etc.),
➜ Threads als Implementierungen von Prozessen in Java
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
13
P ROZESSE VS . T HREADS
• Beide bezeichnen sequentiellen Kontrollfluß
• Prozeß besitzt normalerweise eigenen Speicherbereich,
ist somit relativ schwergewichtig
• Mehrere Threads agieren auf einem Speicherbereich,
sie sind somit leichtgewichtiger als Prozesse
• Insbesondere das Umschalten zwischen Threads geht viel
schneller als zwischen Prozessen
• In Betriebssystemen: threads ≈ leightweight processes
Java ist erste universelle Programmiersprache,
die Threads direkt auf Sprachebene unterstützt
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
14
T HREADS IN JAVA I: E RBEN VON K LASSE T H R E A D
Wie auch viele andere Konzepte in der Java-Welt, werden
Threads über Klassen bzw. Vererbung zur Verfügung gestellt
Erste Methode der Thread-Deklaration
in einem Java Programm:
Thread
➜ Die Java-Klasse Thread beinhaltet eine
(ursprünglich leere) Methode run()
run(){}
➜ Die Benutzer-Klasse MyThread wird
als Unterklasse von Thread deklariert
MyThread
➜ Die (vererbte) Methode run() wird
in MyThread überschrieben
run(){...}
class MyThread extends Thread {
public void run () { ... } }
(Unif. Model. Lang.)
... Thread a = new MyThread ();
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
Klassendiagramm
in UML-Notation
IM
JAVA -U MFELD · VORLESUNG 2
15
T HREADS IN JAVA II: I MPLEMENTIEREN VON R U N N A B L E
Nachteil der ersten Methode: Abgeleitete Klasse
(wie MyThread) darf von keiner anderen Klasse
erben, da Java die Mehrfachvererbung verbietet
Zweite Methode der Thread-Deklaration in Java Programmen:
➜ Java-Interface Runnable enthält abstrakte Methode run()
➜ Die Benutzer-Klasse MyRunnable implementiert Runnable,
indem sie die Methode run() definiert
Merke: Java-Klasse Thread implementiert Runnable ebenfalls
Vor- und Nachteile der zweiten Methode:
+ Kann von anderen Klassen erben
– Kann Instanzmethoden von Thread nicht direkt benutzen.
Umweg: über die Klassenmethode currentThread() erhält
man die Referenz auf den aktuellen Thread in der run-Methode
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
16
Z WEITE M ETHODE : UML D IAGRAMM UND JAVA -D EKLARATION
Runnable
Applet
run(){}
MyRunnable
Thread
run(){...}
run(){}
Z.B. für ein Applet:
class MyRunnable extends Applet implements Runnable {
public void run() { ... }
}
... Thread a = new Thread(new MyRunnable());
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
17
T HREADS IN JAVA I UND II: E RZEUGEN UND S TAR TEN
Ein Thread ist immer ein Objekt der Klasse Thread und wird
(wie jedes Java-Objekt) mit new von einem Konstruktor erzeugt:
➜ Bei der ersten Methode:
Thread a = new MyThread();
➜ Bei der zweiten Methode:
Thread a = new Thread(new MyRunnable());
➜ In beiden Fällen kann der Konstruktor ein String-Argument
haben (der Name des Threads, wird zum Debuggen benutzt);
sonst bekommen die Threads ihre Namen vom System in der
Erzeugungsreihenfolge: Thread-1, Thread-2, ...
➜ Beachte: Ein erzeugter Thread existiert zwar, läuft aber nicht !
Thread muß in beiden Fällen explizit gestartet werden:
a.start();
was die Ausführung seiner run() Methode veranlaßt.
Wichtig: Die run Methode läuft parallel (nebenläufig)
zu dem Thread (evtl. main), der start() ausgeführt hat.
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
18
JAVA T HREAD : L EBENSZYKLUS ALS LTS-D IAGRAMM
sleep
suspend
stop
0
Thread-Zustände:
yield
start
2
1
• 0 = CREATED
resume
3
4
run
stop
end
suspend
dispatch
stop
stop
• 1 = TERMINATED
• 2 = RUNNING
• 3 = NON-RUNNABLE
• 4 = RUNNABLE
Methoden der Klasse Thread sind hier als Aktionen
dargestellt. Einige sind in Java 2 deprecated , d.h. ihre
Implementierung ist nicht mehr garantiert, wie z.B.: stop,
suspend, resume.
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
19
P RAXIS : C OUNT D OWN (F OLIE 12) IN JAVA
COUNTDOWN (N=10) = (start -> COUNTDOWN[N]),
COUNTDOWN[i:0..N] =
(when(i>0) tick->COUNTDOWN[i-1]
| when(i==0) beep -> STOP
| stop -> STOP).
FSP Konstrukte werden in Java wie folgt implementiert:
➜ Aktion start durch die Methode start()
➜ Prozeß COUNTDOWN[i] durch Methode run()
➜ Index i durch Variable int i
➜ Prozesse für alle i durch einen Thread mit Variable i
➜ Rekursion durch while-Schleife
➜ Bedingte Auswahl durch if
➜ STOP durch return von run() oder durch eine
eigene Methode stop(), die den Thread auf null setzt
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
20
C OUNT D OWN ALS JAVA P ROGRAMM ( UNVOLLSTÄNDIG !)
import java . applet , java .awt , concurrency . display ;
public class CountDown extends Applet implements Runnable {
Thread counter ;
//
Java comments are blue
int i; final static int N = 10;
AudioClip beepSound , tickSound ; NumberCanvas display ;
public void init (){...} // prepare applet : display , sounds
public void start () {
// start applet ( no main !)
counter = new Thread (this);
// create thread
i = N; counter . start ();
// start thread ( run !)
}
public void stop (){ counter =null;} // graceful stop
public void run () {
while (true) {
// process COUNTDOWN [i]
// recursion as a loop
if ( counter ==null) return; // STOP - first alternative
if (i >0) ( tick (); --i; }
// tick -> COUNTDOWN [i -1]
if (i ==0){ beep (); return;}} // beep -> STOP }}
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
21
UML D IAGRAMM FÜR C OUNT D OWN
Applet
Runnable
CountDown
init()
start()
stop()
counter
target
Thread
display
NumberCanvas
run()
tick()
beep()
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
setvalue()
IM
JAVA -U MFELD · VORLESUNG 2
22
D ETAILS DER I MPLEMENTIERUNG
“Graceful” Stop:
➜ Eine Möglichkeit – Methode Thread.stop() – killt den Thread,
ohne Ressourcen zu befreien ≈ “Mord”
➜ Unsere Lösung mit counter=null ermöglicht dem Thread
ein return mit clean-up ≈ “Suizid”
➜ Klassenmethode Thread.stop() ist inzwischen deprecated
Implementation von Tick (private Methode von CountDown):
private void tick () {
display . setvalue (i );
// show value of i
tickSound . play ();
// play sound
try{ Thread . sleep (1000);}
// wait 1000 ms = 1 sec
catch ( InterruptedException e ){}} // exception
Beachte: sleep() ist eine Klassenmethode von Thread.
Möglichkeit einer Ausnahme (exception) muß einkalkuliert werden
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
23
WAS WIR HEUTE GELERNT HABEN
• Konzepte:
➜ Prozesse – Einheiten der (evtl. nebenläufigen) Kontrollflüsse
• Modelle:
➜ LTS modelliert Prozesse als Automaten: Graphen mit
Aktionen/Zustandsübergängen. Ablaufspuren: Traces
➜ FSP spezifiziert Prozesse textuell: mit Präfix “->”, Auswahl “|”,
Schleifen, Bedingungen und Rekursion
• Praxis:
➜ Java Threads implementieren Prozesse
➜ Zwei Methoden der Thread-Erzeugung – Thread und Runnable
➜ Erzeugter Thread muß von einem Programm/Thread explizit
gestartet werden und läuft danach mit diesem
gleichzeitig/nebenläufig
➜ Lebenszyklus eines Threads: CREATED, RUNNABLE, RUNNING,
NON-RUNNABLE, TERMINATED
... Notationen: LTS, FSP, UML, Java – jede für eigenen Zweck
c
2003
BY
S ERGEI G ORLATCH · U NI M ÜNSTER · M ULTITHREADING & N ETWORKING
IM
JAVA -U MFELD · VORLESUNG 2
24