Info B VL 15: Multi-Threading

Transkript

1 Info B VL 15: Multi-Threading Objektorientiere Programmierung in Java 2003 Ute Schmid (Vorlesung) Elmar Ludwig (Übung) FB Mathematik/Informatik, Universität Osnabrück Info B VL 15: Multi-Threading p.288

2 Sequentialität und Nebenläufigkeit Sequentielles Programm: zu jedem Zeitpunkt genau ein nächster Ausführungsschritt Nebenläufiges Programm: Anweisungen können parallel bzw. in beliebiger sequentieller Reihenfolge ausgeführt werden {x = i, y = j} v = x; conc w = x v = x end conc; w = x; x = y; x = y; {v = w = i, x = y = j} Info B VL 15: Multi-Threading p.289

3 Willkürliche Sequentialisierung {x = i, y = j} conc w = x v = x end conc; x = y; {v = w = i, x = y = j} ==> w = x; v = x; x = y; v = x; w = x; x = y; Info B VL 15: Multi-Threading p.290

4 Determinismus Ein Programm ist nicht-deterministisch, wenn nicht für alle Anweisungen festgelegt ist, in welcher Reihenfolge sie ausgeführt werden Deterministisch Nicht-Deterministisch {x = i, y = j} v = x; conc w = x v = x end conc; w = x; x = y; x = y; {v = w = i, x = y = j} Info B VL 15: Multi-Threading p.291

5 Determiniertheit Jede Programmausführung liefert bei gleichen Ausgangswerten das identische Ergebnis. Determiniert Nicht-Determiniert {x = i, y = j} {x = i, y = j} conc w = x v = x end conc; conc w = x v = x x = y; x = y end conc; {v = w = i, x = y = j} {v =?, w =?, x = y = j} Info B VL 15: Multi-Threading p.292

6 Determinismus und Determiniertheit Ein deterministisches Programm ist immer determiniert. Bei nicht-deterministischen Programmen, sind Ergebnisse genau dann determiniert, wenn keine Schreib-/Schreib- und keine Schreib-/Lese-Konflikte auftreten (Veränderung von Variablen-Werten) Info B VL 15: Multi-Threading p.293

7 Verzahnung Bei der Sequentialisierung nebenläufiger Anweisungsfolgen muss nur die in jeder Anweisungsfolge vorgegebene Sequenz beachtet werden. Ansonsten kann beliebig verzahnt werden (interleaving). Bei jeder Programmausführung kann eine andere Verzahnung auftreten. Die Programmausführung ist nicht reproduzierbar. Fehler können sich je nach Verzahnung nur gelegentlich bemerkbar machen. nebenläufige Programm sind schwerer zu validieren und zu verifizieren als sequentielle! Info B VL 15: Multi-Threading p.294

8 Beispiel conc w = x; v = w+1 y = x; z = y end conc Mögliche Sequentialisierungen (1) w = x; v = w+1; y = x; z = y; (2) y = x; z = y; w = x; v = w+1; Weitere Verzahnungen (3) w = x; y = x; v = w+1; z = y; (4) w = x; y = x; z = y; v = w+1; (5) y = x; w = x; v = w+1; z = y; (6) y = x; w = x; z = y; v = w+1; Info B VL 15: Multi-Threading p.295

9 Threads in Java Greifen verschiedene (nebenläufige) Aktivitäten auf verschiedene Adressräume zu, so spricht man von (parallelen) Prozessen. Findet Nebenläufigkeit im selben Adressraum statt (z.b. eine Java VM), so spricht man von Threads ( Programmfäden ). (Addressraum: Menge aller zugreifbaren Speicherbereiche.) In Java sind Threads integraler Bestandteil der Sprache und nahtlos in das Konzept der Objekt-Orientierung eingebaut (Threads sind Objekte). Probleme: Synchronisation, Deadlocks Info B VL 15: Multi-Threading p.296

10 Definition von Threads Thread MAX_PRIORITY... sleep() Runnable <<interface>> run() run() start() join()... ErsterThread run() runs ZweiterThread run() Info B VL 15: Multi-Threading p.297

11 Klasse Thread Die run()-methode definiert, was ein Thread (quasi gleichzeitig mit anderen Threads) ausführen möchte (analog zu main()). Wichtige Methoden: start(): Starten des Threads (Aufruf der run()-methode beim Runnable durch das System). join(): Warten auf das Zuendegehen eines Threads. sleep(long): Schlafenlegen eines Threads. yield(): Pausieren, um anderen Threads eine Chance zu geben. Info B VL 15: Multi-Threading p.298

12 Prioritäten setpriority(int)} {\tt getpriority() MIN_PRIORITY = 1 MAX_PRIORITY = 10 NORM_PRIORITY = 5 ; Konventionen: 10 Crisis Management 7-9 Interactive, event-driven 4-6 IO-bound 2-3 Background computation 1 Run only, if nothing else can Info B VL 15: Multi-Threading p.299

13 Beispiel (1) // Set a thread t to lower than normal priority t.setpriority(thread.norm_priority-1); // Set a thread to lower priority than the current thread t.setpriority(thread.currentthread().getpriority()-1); // Threads that don t pause for I/O should explicitely yield the CPU // to give other threads with the same priority a chance to run. Thread t = new Thread(new Runnable() { public void run() { for(int i = 0; i < data.length; i++) { // Loop through data process(data[i]); // Process it if (i % 10 == 0) // After every 10 iterations Thread.yield(); // Let other threads run. } } }); Info B VL 15: Multi-Threading p.300

14 Beispiel (2) Beispielcode: ThreadDemo.java Zusammenspiel von Threads main start thread1 start thread2 join thread2 join thread1 thread1 thread2 Zeit Info B VL 15: Multi-Threading p.301

15 Zustände von Threads vorhanden bereit laufend fertig wartend (blockiert) vorhanden: mit new als Instanz erzeugt. bereit: ablaufbereit, aber die Ablaufsteuerung hat alle CPUs an andere Threads vergeben. laufend: hat eine CPU des Systems. wartend: es fehlen Betriebsmittel (z. B. File ist nicht zum Lesen/Schreiben freigegeben), sleep() oder Warten auf Signal eines anderen Threads. fertig: Ende der run()-methode erreicht. Info B VL 15: Multi-Threading p.302

16 Kooperierende Prozesse Nebenläufige Prozesse, die Koordination erfordern, heissen voneinander abhängig. Grundlegende Kommunikationsformen Erzeuger/Verbraucher Muster (producer/consumer): Ein Prozess nimmt Daten auf, die ein anderer erzeugt hat. Beispiel: Buchungssystem im Supermarkt Auftraggeber/Auftragnehmer Muster (client/server) Beispiel: Verkehrsleitzentrale. Info B VL 15: Multi-Threading p.303

17 Arten der Kooperation Produzent Auftraggeber 1 2 Konsument Auftragnehmer Info B VL 15: Multi-Threading p.304

18 Beispiel Buchungssystem Butter 2 1,29 Kaffee 1 7,99... Lesen Buchen Drucken Info B VL 15: Multi-Threading p.305

19 Konkurrierende Prozesse Abhängigkeit nebenläufiger Prozesse kann auch aus Konkurrenz der Prozesse (um gemeinsame Ressourcen) resultieren. Die Aktivität eines Prozesses behindert einen anderen Prozess. Beispiel: Eingleisige Teilstrecke im Eisenbahnverkehr Beispiel: Drucker im Mehrbenutzersystem Info B VL 15: Multi-Threading p.306

20 Schreib-/Schreib-Konflikt conc x = x + 1 x = x + 1 end conc; kann zu ein- oder zweimaliger Inkrementierung von P1 P2 x r1 r2 i?? LOAD x, r1 i i? LOAD x, r2 i i i INCR r1 i i+1 i INCR r2 i i+1 i+1 STORE r1,x i+1 i+1 i+1 führen STORE r2,x i+1 i+1 i+1 ( STORE r1,x direkt nach INCR r1 resultiert in zweimaliger Inkrementierung) Info B VL 15: Multi-Threading p.307

21 Schreib-/Lese-Konflikt (1) int schecks; int gesamt; void einnahme(boolean zahlungsart, int betrag) { // zahlungsart false = bar, true = scheck if (zahlungsart) schecks = schecks + betrag; gesamt = gesamt + betrag; } void kassensturz () { System.out.println("Einnahmen: " + gesamt); if (gesamt > 0) System.out.println("Davon prozentual " + "als Scheckzahlung: " * schecks/gesamt); } Info B VL 15: Multi-Threading p.308

22 Schreib-/Lese-Konflikt (2) Gegebener Kontostand sei 100,- Euro. Wenn einnahme(1, 200) und kassensturz() nebenläufig abgearbeitet werden, kann es zu inkonsistenten Informationen kommen: P1 P2 gesamt scheck Output schecks kassensturz % gesamt Info B VL 15: Multi-Threading p.309

23 Synchronisation Die gezielte Sequentialisierung nebenläufiger Prozesse heisst Synchronisation. Synchronisierte Prozesse müssen Information austauschen, also kommunizieren. Kommunikation kann realisiert werden durch: (1) gemeinsamen Datenbereich, auf den mehrere Prozesse zugreifen können. (2) Operationen, die Daten vom Datenbereich eines Prozesses in den des anderen transportieren. Anstelle ganzer Prozesse können auch kritische Abschnitte (Anweisungsblöcke) synchronisiert werden. Info B VL 15: Multi-Threading p.310

24 Arten von Synchronisation ( und seien verschiedenen Prozessen zugeordnete Aktivitäten) Kausale Abhängigkeit (Produzent/Konsument): Transitiver Abschluss (partielle Ordnung der Aktivitäten ) Einseitige Synchronisation (blockiert wird höchstens ) erzwingt Reihenfolge. (vgl. Supermarkt-Buchungssystem) Ausschluss der Nebenläufigkeit (Schreib-/Schreib- und Schreib-/Lese-Konflikte): Symmetrie von nicht zusammen mit Mehrseitige Synchronisation: Bei gleicher Priorität ist keine Reihenfolge festgelegt. (vgl. eingleisiges Eisenbahnstück) Info B VL 15: Multi-Threading p.311

25 Monitore in Java (1) Wird mehr als ein Thread verwendet, so tritt häufig Synchronisations-Bedarf auf. Zugriff auf kritische Daten muss kontrolliert werden. Hierzu wird ein Monitor-Objekt eingesetzt, das den Zugang von Threads zu den Daten steuert. (Jedes beliebige Objekt kann als Monitor verwendet werden.) In Java wird synchronized verwendet, um einen kritischen Bereich zu definieren und diesem Bereich ein Monitor-Objekt zuzuordnen. synchronized(monitor) für Blöcke (kritische Abschnitte) Info B VL 15: Multi-Threading p.312

26 Monitore in Java (2) Wenn sich ein synchronized(this)-block auf eine komplette Methode bezieht, kann alternativ der Modifikator synchronized für diese Methode angegeben werden. Der Modifikator synchronized kann auch für Klassen-Methoden angegeben werden. Hier wird das Klassen-Objekt zum Monitor. Info B VL 15: Multi-Threading p.313

27 Kommunikation bei Monitoren wait() (Warte und gib den Monitor frei), notify() (Benachrichtige einen auf den Monitor wartenden Thread) und notifyall() (Benachrichtige alle auf den Monitor wartenden Threads). Diese Methoden gehören nicht zur Klasse Thread, sondern zu einem Monitor-Objekt! Info B VL 15: Multi-Threading p.314

28 Illustration Monitor geschützte Daten Zugang zum Monitor blockiert für alle anderen Threads Info B VL 15: Multi-Threading p.315

29 Synchronized Methoden synchronized void einnahme(boolean zahlungsart, int betrag if (zahlungsart) schecks = schecks + betrag; gesamt = gesamt + betrag; } synchronized void kassensturz () { System.out.println("Einnahmen: " + gesamt); if (gesamt > 0) System.out.println("Davon prozentual " + als Scheckzahlung: " * schecks/gesamt); } Info B VL 15: Multi-Threading p.316

30 Synchronized Blöcke // This method swaps two array elements // in a synchronized block public static void swap(object[] array, int index1, int index2) { synchronized(array) { Object tmp = array[index1]; array[index1] = array[index2]; array[index2] = tmp; } } Info B VL 15: Multi-Threading p.317