Zur Erinnerung: Threads. Threadverwaltung. Threads: Prioritäten. Beispiel Flugbuchungsprogramm. Nichtdeterminismus

Transkript

1 Zur Erinnerung: Threads Programmierung (fortgeschrittene Konzepte) Threads, Monitore, Semaphore und speisende en Wolf-Ulrich Raffel Möglichkeiten, Threads zu definieren Bildung einer Unterklasse von Thread Überschreiben der run()-methode Implementierung des Interfaces Runnable Starten mittels start() Thread führt run()-methode aus Thread kann sich schlafen legen mittels Thread.sleep() Warten, dass ein anderer Thread abgelaufen ist Aufrufen der join()-methode des Threads 7..5 Threads, Monitore, Semaphore und speisende en 7..5 Threads, Monitore, Semaphore und speisende en Threads: Prioritäten Jeder Thread hat natürliche Zahl als Priorität Thread.MIN_PRIORITY = Thread.NORM_PRIORITY = 5 Thread.MAX_PRIORITY = Virtual Machine KANN Prioritäten berücksichtigen Sinnvolle Prioritätsvergabe: Rechnen: niedrig Ein-/Ausgabe: mittel Ein-/Ausgabe mit Realzeitanforderung: hoch Threadverwaltung Ähnlich wie Prozessverwaltung im Betriebssystem Sind mehr Threads rechenbereit (RUNNABLE) als Prozessoren vorhanden, enthalten sie abwechselnd (oder nach Proritäten abgestuft) kleine Zeitfenster zum Rechnen 7..5 Threads, Monitore, Semaphore und speisende en 7..5 Threads, Monitore, Semaphore und speisende en Nichtdeterminismus Sequentielles Programm ohne explizite Benutzung von Zufallszahlen deterministisch gleiche Eingaben führen zu gleichen Zustandsfolgen determiniert gleiche Eingaben führen zu gleichen Ausgaben Nichtsequentielles Programm (Benutzung von Threads) nichtdeterministische Abläufe aber möglich (und erwünscht): determinierte Ergebnisse Beispiel Flugbuchungsprogramm static int freeseats = ; int a = freeseats; a = a ; freeseats = a; int b = freeseats; b = b 5; freeseats = b; Erwartetes Ergebnis: freeseats = Threads, Monitore, Semaphore und speisende en Threads, Monitore, Semaphore und speisende en 6

2 Beispielablauf Beispielablauf static int freeseats = ; static int freeseats = ; int a = freeseats; // a = a ; //97 int b = freeseats; //97 b = b 5; //9 freeseats = b; //9 int a = freeseats; // a = a ; //97 int b = freeseats; // b = b 5; //95 freeseats = b; //95 Ergebnis: freeseats = Threads, Monitore, Semaphore und speisende en 7 Ergebnis: freeseats = Threads, Monitore, Semaphore und speisende en 8 Beispielablauf static int freeseats = ; int a = freeseats; // a = a ; //97 Ergebnis: freeseats = 97 int b = freeseats; // b = b 5; //95 freeseats = b; // Threads, Monitore, Semaphore und speisende en 9 Praxistest Mehrere Threads führen parallel in einer for-schleife mehrere Iterationen einer Flugbuchung durch z.b. Threads, Iterationen, gebuchter Platz, Plätze verfügbar Am Ende noch (viele) Plätze übrig Effekt nur beobachtbar, wenn Thread nicht in einem Zeitfenster fertig 7..5 Threads, Monitore, Semaphore und speisende en Verbesserung (?) Flugbuchungsprogramm static int freeseats = ; freeseats = freeseats ; Erwartetes Ergebnis: freeseats = 9 Praxistest: erneut viele Plätze übrig Aber warum? freeseats = freeseats - 5; Umsetzung in Bytecode / Maschinensprache freeseats = freeseats ; LW freeseats,$r // R = freeseats LW,$R // R = SUB $R,$R,$R // R = R R SW freeseats,$r // freeseats = R (LW = loadword, SW = StoreWord) 7..5 Threads, Monitore, Semaphore und speisende en 7..5 Threads, Monitore, Semaphore und speisende en

3 freeseats = LW freeseats,$r // LW,$R SUB $R,$R,$R //97 SW freeseats,$r //97 Beispielablauf Ergebnis: freeseats = 95 LW freeseats,$r // LW 5,$R SUB $R,$R,$R //95 SW freeseats,$r //95 Kritische Abschnitte Kritische Abschnitte sind Codeabschnitte, die mehrere Threads nicht gleichzeitig ausführen dürfen, z.b. Zugriff auf gemeinsame Variable Nutzung einer Ressource 7..5 Threads, Monitore, Semaphore und speisende en 7..5 Threads, Monitore, Semaphore und speisende en Kritische Abschnitte in Java Realisierung in Java synchronized (o) { synchronized Methode: wie synchronized(this) {Methodenrumpf Zwischen kritischen Abschnitten, die sich auf das gleiche Objekt beziehen, ist wechselseitiger Ausschluss garantiert. Man hält Sperre auf diesem Objekt synchronized (x) { synchronized (y) { Verklemmung synchronized (y) { synchronized (x) { Hier kann es zu einer Verklemmung kommen Beide Threads können mehr weiterrechnen 7..5 Threads, Monitore, Semaphore und speisende en Threads, Monitore, Semaphore und speisende en 6 Monitor Ein Monitor ist ein Objekt mit vollständiger Datenabstraktion wechselseitigem Ausschluss bei allen Operationen Monitor in Java: alle public-methoden synchronized Beispielanwendungen ArrayStack, LinkedStack, ArrayQueue, LinkedQueue, ArraySet, BinSearchTree, 7..5 Threads, Monitore, Semaphore und speisende en 7 Beispiel: pop bei ArrayStack public E pop() throws StackUnderflow { if (top==-) { throw new StackUnderflow(); top--; return values[top+]; Zwei nebenläufige Aufrufe von pop() Wenn zwischen der vorletzten und letzten Zeile Thread x durch Thread y unterbrochen wird: gelöschter Wert von Thread x () wird nicht zurückgegeben dafür gelöschter Wert von Thread y () durch beide Threads 5 7 top 7..5 Threads, Monitore, Semaphore und speisende en 8

4 wait, notify und notifyall Methoden der Klasse Object Nur zulässig, wenn man Objekt mittels synchronized gesperrt hat sonst IllegalMonitorStateException wait() gibt Sperre frei blockiert Thread, bis er aufgeweckt wird oder bis Timeout (wenn übergeben) notify() weckt einen blockierten Thread auf gibt Sperre (noch) nicht frei notifyall() weckt alle blockierten Threads auf 7..5 Threads, Monitore, Semaphore und speisende en 9 Beispiel: Drucker public class Printer { private boolean occupied; public synchronized void request() { while (occupied) { wait(); occupied = true; public synchronized void release() { occupied = false; notify(); 7..5 Threads, Monitore, Semaphore und speisende en Semaphore Ein Semaphor ist ein Synchronisationsobjekt Unabhängig von Monitor Vorbild: Flügelsignale bei der Bahn Operationen: P (passeren, holländisch für passieren) V (vrijgeven, holländisch für freigeben) Semaphore () Ein Semaphor hat Initialwert In der Regel (binäres Semaphor) P-Operation Wenn der Wert des Semaphors größer ist Wert um erniedrigen Sonst Thread anhalten und warten V-Operation Wenn Wert des Semaphors ist und mind. ein Thread wartet einen wartenden Thread aufwecken Sonst Wert um erhöhen 7..5 Threads, Monitore, Semaphore und speisende en 7..5 Threads, Monitore, Semaphore und speisende en Implementierung Semaphor public class Semaphore { int s; public Semaphore (int s) { this.s=s; public synchronized void p() { while (s==) { try { wait(); catch (InterruptedException e) { s--; public synchronized void v() { s++; notify(); 7..5 Threads, Monitore, Semaphore und speisende en Fairness und Verklemmungsfreiheit Eine Ressourcenvergabe ist fair wenn jeder Thread, der auf eine Ressource wartet, sie irgendwann bekommt In Java keine Fairnessgarantien verklemmungsfrei wenn sichergestellt ist, dass zu keiner Zeit mehrere Threads auf eine Ressource warten und es keine mögliche Programmfortsetzung gibt, die diese Situation ändert Verklemmung entsteht z.b. durch zyklisches Warten 7..5 Threads, Monitore, Semaphore und speisende en

5 Verhinderung von Verklemmungen Eine Verklemmung entsteht bei zyklischem Warten auf Ressourcen Wenn eine Ordnung auf Ressourcen existiert: Jeder Thread, der mehrere Ressourcen benötigt, muss diese in aufsteigender Ordnung anfordern Dann ist Zyklenfreiheit garantiert Speisende en 5 en an rundem Tisch Jeweils eine Gabel zwischen en Jeder denkt abwechselnd nach und isst Man braucht zum Essen zwei Gabeln Gabel Gabel Gabel Gabel 7..5 Threads, Monitore, Semaphore und speisende en Threads, Monitore, Semaphore und speisende en 6 Zugriffsstrategie Jeder wartet, bis beide Gabeln frei sind und nimmt sie sich dann Nicht fair Ein kann zwischen zwei sich abwechselnden en verhungern Gabel 7..5 Threads, Monitore, Semaphore und speisende en 7 Gabel Gabel Gabel Zugriffsstrategie Jeder nimmt erst die rechte, dann die linke Gabel auf Nicht verklemmungsfrei Wenn alle en eine Gabel aufgenommen haben, kommt es zur Verklemmung Gabel 7..5 Threads, Monitore, Semaphore und speisende en 8 Gabel Gabel Gabel Zugriffsstrategie Jeder nimmt erst die Gabel mit kleinerer Nummer, dann die Gabel mit größerer Nummer auf en,, und erst rechts, dann links erst links, dann rechts Gabel 7..5 Threads, Monitore, Semaphore und speisende en 9 Gabel Gabel Gabel Zugriffsstrategie Jeder nimmt erst die rechte, dann die linke Gabel auf nimmt nur dann Gabel auf, wenn nicht bereits alle anderen en Gabel aufgenommen haben Gabel 7..5 Threads, Monitore, Semaphore und speisende en Gabel Gabel Gabel 5