Threads - und wie sie in Java implementiert sind. Vortrag von Lukas Klimmasch, Stefan Lang und Ralf Schmidt Jena, den

Transkript

1 Threads - und wie sie in Java implementiert sind Vortrag von Lukas Klimmasch, Stefan Lang und Ralf Schmidt Jena, den

2 Was ist ein Thread? laut Wikipedia: ein Ausführungsstrang oder eine in der Abarbeitung eines Programms am ehesten mit Nebenläufigkeit zu übersetzen Idee: - Programm durch Programmierer oder Compiler in mehrere voneinander unabhängige Teile zerlegen - Befehle verschiedener Prozesse, die naturgemäß keine Abhängigkeiten haben, durchmischen nicht multi-tasking (mehrere Prozesse); Aufteilung eines einzelnen Prozesses

3 verschiedene Ebenen für Threads: - simultanes Multi-Threading (SMT) ein Prozessorkern, dessen Architektur die scheinbare Abarbeitung mehrerer Threads erlaubt Quelle: Skript Rechnerstrukturen, Prof. Erhard

4 verschiedene Ebenen für Threads: - simultanes Multi-Threading (SMT) ein Prozessorkern, dessen Architektur die scheinbare Abarbeitung mehrerer Threads erlaubt - BS organisiert Prozesse in Threads Quelle: Skript Rechnerstrukturen, Prof. Erhard

5 verschiedene Ebenen für Threads: - simultanes Multi-Threading (SMT) ein Prozessorkern, dessen Architektur die scheinbare Abarbeitung mehrerer Threads erlaubt - BS organisiert Prozesse in Threads Quelle: Skript Rechnerstrukturen, Prof. Erhard

6 verschiedene Ebenen für Threads: - simultanes Multi-Threading (SMT) ein Prozessorkern, dessen Architektur die scheinbare Abarbeitung mehrerer Threads erlaubt - BS organisiert Prozesse in Threads - Programmierer unterteilt Programm in Threads Quelle: Skript Rechnerstrukturen, Prof. Erhard

7 Zweck von Threads überproportionaler Anstieg an elektrischer Leistung und Chip-Fläche im Vergleich zur Rechenleistung Quelle: Skript Rechnerstrukturen, Prof. Erhard effizientere Nutzung der Ressourcen nötig Geschwindigkeitszugewinn

8 Ein anschauliches Beispiel Prozess: Zubereitung des Weihnachtsessen verschiedene Threads: Gans Klöße Nachtisch nicht: erst die Gans, dann die Klöße, dann der Nachtisch sondern: Gans im Ofen Klöße zubereiten um den Nachtisch kümmern Vorteil: alles gleichzeitig fertig Zeit gespart/effizienter gearbeitet

9 Threads in Java Programmierung von Threads in Java möglich JVM bildet Threadverwaltung auf BS ab (falls dieses Threads unterstützt) sonst leistet JVM Verwaltung gute Planung des Programmierers nötig Nachteil von Threads: hoher Grad an Koordination nötig! Programmcode wird fehleranfälliger mögliche Fehlerfälle müssen vom Programmierer behandelt werden mögliche Fehlerfälle (Bsp): gemeinsam genutzte Ressourcen mehrere Schreibevorgänge falsche Reihenfolge (write after read)

10 Threads in Java erzeugen Die Klasse Thread: Objekte führen über start() den Thread aus jedes neu erzeugte Objekt entspricht einem Thread möglicher Quellcode:

11 Threads in Java erzeugen Die Klasse Thread: Objekte führen über start() den Thread aus jedes neu erzeugte Objekt entspricht einem Thread möglicher Quellcode:

12 Threads in Java erzeugen Die Klasse Thread: Objekte führen über start() den Thread aus jedes neu erzeugte Objekt entspricht einem Thread möglicher Quellcode: Welchen Code startet start()?

13 Threads in Java erzeugen Die Klasse Thread: Objekte führen über start() den Thread aus jedes neu erzeugte Objekt entspricht einem Thread möglicher Quellcode: Welchen Code startet start()? Was ist das?

14 Die Schnittstelle Runnable UML-Diagramm Klassen implementieren Runnable in run(): nebenläufig auszuführenderprogrammcode Runnable-Objekt an Thread übergeben

15 Kleine Zusammenfassung Klasse implementiert Runnable nebenläufiger Programmcode in run() Objekt der Klasse Thread start() Thread-Starten und Ausführen

16 weitere Möglichkeit: Klasse Thread erweitern implementiert selbst Runnable stellt run() bereit keine Runnable-Übergabe im Konstruktoraufruf nötig Aufruf von start() ausreichend

17 Qual der Wahl? Thread-Erweiterung Runnable implementieren Einfachvererbung ein mögliches Problem Runnable-Objekte recht flexibel leicht zu übergeben von Threads aus einem Threadpool ausführbar (später)

18 Eigenschaften von Threads Name: Zugriff über getname(), setname() bzw. im Konstruktor Priorität: wird im Konstruktor zugewiesen (zulässige Werte: 1 bis 10, Standard ist 5) Zustand: Zugriff über getstate()

19 Zustände von Threads Zustand Bedeutung NEW Thread ist neu und wurde noch nicht gestartet RUNNABLE Thread läuft in der Java Virtual Machine BLOCKED Thread ist z.b. in einem synchronised-block WAITING Thread wartet etwa auf ein notify() TIMED_WAITING Thread wartet nach einem sleep()-befehl TERMINATED Thread wurde beendet

20 Threads als Dämonen es gibt Threads, die eine Endlosschleife beinhalten sinnvoll, wenn die Threads während der Ausführung des gesamten Programmes im Hintergrund laufen müssen, z.b. Garbage Collector ein Thread, der als Dämon deklariert wurde, wird beendet, sobald das Hauptprogramm beendet wird im Konstruktor: setdeamon(true)

21 Beispiel Dämonen public class DeamonThread extends Thread { DeamonThread(){ this.setdaemon(true); //Thread wird zum public void run(){ while(true){ //Endlosschleife System.out.println( Ich bin ein Dämon!! );

22 Beispiel Dämonen public static void main(string[] args{ new DeamonThread().start(); mögliche Ausgabe: Ich Ich Ich Ich Ich... bin bin bin bin bin ein ein ein ein ein Dämon!! Dämon!! Dämon!! Dämon!! Dämon!! insgesamt ca. 15 Mal, oder auch gar nichts...

23 Nachteile beim Arbeiten mit Instanzen der Klasse Thread beim Aufruf des Konstruktors wird eine Instanz eines Runnable-Objektes einem Thread-Objekt zugewiesen run()-methode kann nur ein einziges Mal abgearbeitet werden Rückgabewert von run() ist void...

24 Thread-Pools Interface Executor: kann eine Runnable ausführen Interface ExecutorService: erbt von Executor und bietet einige nützliche Operationen an, wie z.b. den ThreadPool herunterfahren Klasse Executors: liefert je nach Bedarf verschiedene Thread-Pools, z.b. einen Pool mit fester oder wachsender Anzahl an Threads

25 Übersicht Quelle:

26 Beispiel Thread-Pools public class Printi implements Runnable { String message; public Printi(String text){ this.message= public void run(){ //Druckt Nachricht und Namen des Threads aus System.out.println(this.message + " gedruckt von " + Thread.currentThread());

27 Beispiel Thread-Pools public static void main(string[] args{ Printi p1 = new Printi("Nummer 1"); Printi p2 = new Printi("Nummer 2"); ExecutorService executor = Executors.newCachedThreadPool(); executor.execute(p1); executor.execute(p2); executor.execute(p1); executor.execute(p2); executor.shutdown(); Ausgabe: "Nummer "Nummer "Nummer "Nummer 1" 2" 1" 2" gedruckt gedruckt gedruckt gedruckt von von von von Thread[pool-1-thread-1,5,main] Thread[pool-1-thread-2,5,main] Thread[pool-1-thread-2,5,main] Thread[pool-1-thread-1,5,main]

28 Das Interface Callable im Prinzip wie Runnable, nur mit call()-methode und generischem Rückgabewert benötigt submit()-methode z.b. aus von einem ExecutorService-Objekt

29 Beispiel Callable import java.util.concurrent.callable; //implementiert Callable mit generischem Datentyp public class CallClass implements Callable<Integer>{ int result; public CallClass(int i){ public Integer call(){ //hat jetzt Rückgabewert int k = this.result; for(int j=0; j<k; j++){ this.result += this.result; return this.result;

30 Das Futur<V> Objekt Generischer Datentyp zum Abspeichern von asynchron einkommenden Ergebnissen wichtige Methoden: V get() throws InterruptedException, ExecutionException V get(long timeout, TimeUnit unit) throws InterruptedException,ExecutionException, TimeoutException boolean isdone() boolean cancel(boolean mayinterruptifrunning)

31 Beispiel Callable public static void main(string[] args{ CallClass c = new CallClass(2); ExecutorService executor = Executors.newCachedThreadPool(); //generisches Future-Objekt zum Auffangen des Ergebnisses Future<Integer> result = executor.submit(c); //get-methode holt das Ergebnis System.out.println(result.get()); Ausgabe: 16

32 Synchronisation Problem: Mehrere Threads arbeiten auf den selben Daten und kommen sich dabei in die Quere Lösung: Threads so synchronisieren, dass keiner den anderen stört

33 Beispiel 1 gemeinsam genutzte Daten class Name { String firstname; String surname; private int counter; public void setname (String firstname, String surname) { //kritische this.firstname = firstname; //<-Abschnitte, da this.surname = surname; //<-Vorname und Nachname zusammengehören, public String getname() { aber zugreifende Threads beim schreiben und lesen Counter++; //<-unterbrochen werden können. Auch der ++ return firstname + " " + surname;//<-operator ist kritisch für Threads (Quelle: Multithreading/Synchronisation.html)

34 ... Name n; // thread 1: // thread 2: n.setname("charlie","chaplin"); n.getname() n.setname("jerry","lewis");... Mögliche Ausgaben für n.getname(): "Charlie Chaplin" "Jerry Lewis" "Jerry Chaplin" "Charlie Lewis"

35 Threadsicherheit Definition: Eine Komponente des Programms wird als threadsicher bezeichnet, wenn sie gleichzeitig von verschiedenen Programmbereichen mehrfach ausgeführt werden kann, ohne dass diese sich gegenseitig behindern. Hier keine Synchronisation nötig!

36 Beispiele für threadsichere Klassen: Immutable-Klassen: "Klassen, in denen keine schreibzugriffe erfolgen und die Lesezugriffe unproblematisch sind" (z.b. String oder Wrapper-Klassen) Jeder Thread bekommt eigenen Stack --> Alle Methoden, die keine Objektvariablen verändern, sind threadsicher

37 Beispiel Threadsicherheit... public static String reverse( String s ){ return new StringBuilder( s ).reverse().tostring();... Jeder Thread wird eine eigene Variablenbelegung für s haben und ein temporäres Objekt vom Typ StringBuilder referenzieren. Quelle: bd2eaf4ea985fe997b1df29eff

38 Leider sind die meisten Klassen nicht Threadsicher... Klassen mit statischen Attributen (z.b. Die Klasse Thread selbst wenn man sie ableitet und ein statisches Attribut hinzufügt) Auch die meisten Java-Klassen sind nicht Threadsicher Beispiel "DateFormat", auszug aus JavaDoc: "Synchronization. Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally." Hier ist Synchronisation nötig!

39 Wie kann Synchronisation in Java erreicht werden? Zwei Wege: "Schützen" der kritischen Abschnitte Warten und Benachrichtigen

40 Schlüsselwort "synchronized" (seit Java 1.0) Methoden: synchronized Type method(...) { // der gesamte Rumpf ist synchronisiert mit this... Blöcke: synchronized ( e ) { // dieser Block wird synchronisiert // mit dem Objekt, das durch e referenziert wird... Quelle: Synchronisation.html

41 Schnittstelle Lock (seit Java 5.0) lock.lock(); //zuschließen { // dieser Block wird synchronisiert lock.unlock(); //wieder aufschließen Wichtigste Implementierung: ReentrantLock() (Verhindert, dass sich ein Thread selbst "aussperren kann") Das Schlüsselwort "synchronized" bestimmt Anfang und Ende des kritischen Abschnittes automatisch, bei Lock muss das wieder öffnen explizit angegeben werden

42 Quelle: bd2eaf4ea985fe997b1df29eff

43 Synchronisation durch Warten und Benachrichtigen Wieder zwei Wege: wait() und notify() Schnittstelle Condition Seit Java 1.0 Methoden der Klasse "Object" Funktionieren nur in Zusammenhang mit "synchronized (o)", Seit Java 5.0 Funktioniert nur mit einem Lock() Objekt, welches durch lock.getcondition() ein Condition() Objekt erzeugen kann

44 ... // erster Thread synchronized( o ) { try { o.wait(); // Habe gewartet, kann jetzt loslegen. catch ( InterruptedException e ) { //zweiter Thread... synchronized( o ) { // Habe etwas gemacht und informiere jetzt meinen Wartenden. o.notify(); // bzw. o.notifyall()... Quelle: #mj0ba218bd2eaf4ea985fe997b1df29eff

45 Quelle:

46 Condition condition = lock.newcondition();... lock.lock(); Try { condition.await(); catch ( InterruptedException e ) {... Finally { lock.unlock(); //gleiches Schema wie wait() und notify(), die Synchronisation erfolgt jedoch über ein LockObjekt... condition.signal(); Quelle: b58ede047a8963da930acab3fa6052