Threads in Java. Threads. Die Klasse Thread. Erzeugen eines neuen Threads. Threads. Ein Thread. Alle Threads eines Programms A B C.

Transkript

1 Threads Ein Thread ist ein eigenständiges Programmstück, das parallel zu anderen Threads laufen kann kann mit einem Prozeß verglichen werden, läuft jedoch auf einer feineren Stufe ab Ein Prozeß ist ein Instrument, um ein komplettes Programm auszuführen Innerhalb eines Prozesses können mehrere Threads parallel ablaufen Alle Threads eines Programms teilen sich einen gemeinsamen Adressraum Adressräume von Prozessen sind streng getrennt können auf gleiche Variablen zugreifen Programm / Prozess A Programm / Prozess A B C Ein Thread Mehrere Threads Threads in Java Threads sind direkter Bestandteil der Sprache Java sind immer Instanzen einer Klasse, die das Interface Runnable implementiert Runnable deklariert nur die (abstrakte) Methode void run() run() enthält alle im Thread auszuführenden Anweisungen Instanzen von Klassen, die Runnable implementieren, heißen (Thread)-Targets kommunizieren durch Zugriff auf Instanz- oder Klassenvariablen Aufruf von Methoden, die innerhalb von run() sichtbar sind werden gesteuert durch die Klasse Thread (aus java.lang.thread) Thread implementiert das Interface Runnable Jede Instanz von Thread (oder einer von Thread abgeleiteten Klasse) ist Target eines Threads (kann als Thread ausgeführt werden) FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 2 Die Klasse Thread Konstruktoren public Thread() public Thread(String name) public Thread(Runnable target) public Thread(Runnable target, String name) Methoden void run() void start() throws IllegalThreadStateException static void sleep(long millis) finale boolean isalive() Generischer Name Thread-<nummer> Thread-Name Thread-Target Enthält auszuführenden Programmcode Wenn Thread schon gestartet true wenn Thread gestartet wurde final void setname() final String getname() final void setpriority(int prio) final int getpriority() FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 3 Erzeugen eines neuen Threads Zum Erzeugen eines Threads muss eine Klassen von Thread abgeleitet werden die Methode run() überschrieben werden Gestartet wird ein Thread durch den Aufruf von start() Anschließend wird die weitere Ausführung automatisch an die Methode run übertragen Direkter Aufruf von run würde keinen neuen Thread erzeugen public class SimpleThread MyThread thread = new MyThread(); Out.println("Starting thread..."); try Thread.sleep(20); catch (InterruptedException e) thread.stop(); // Deprecated!!! Out.println("Thread has been stopped!"); class MyThread extends Thread int counter=0; while(true) Out.println(getName()+ : +counter++); Würde wie ein normaler Methodenaufruf aus dem Programm-Ausgabe Starting thread... laufenden Thread behandelt Thread-0: 1 Thread-0: 2.. Thread-0: 321Thread has been stopped! FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 4

2 Beenden eines Threads Beispiel Ein Thread sollte nicht mit der Methode stop() beendet werden Es ist nicht definiert und auch nicht voraussagbar, wann der Thread beendet wird Threads am besten durch Verwendung eines Flags beenden Variable z.b. boolean stopmythread zeigt an, ob Thread stoppen soll Target Thread überprüft die Variable stopmythread regelmässig Beendet die Methode run(), wenn die stopmythread gleich true ist Damit sofort auf stop reagiert wird, muss entweder die Variable volatile sein, oder Mit dem Schlüsselwort volatile werden Variablen gekennzeichnet, die asynchron (außerhalb des aktuellen Threads) modifizierbar sein sollen. der Zugriff auf die Variable synchronisiert sein FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 5 class MyStopThread extends Thread private volatile Thread thread = this; //private volatile boolean cancel = false; /* Die Methode stop() kann nicht überschrieben werden da sie final ist */ mystop() thread = null; //cancel = true; Thread thisthread=thread.currentthread(); int counter = 0; while (thread == thisthread) // while (!cancel) Out.print(currentThread()+": ); Out.println(counter++); public class MyStopThreadExample MyStopThread thread = new MyStopThread(); Out.println("Starting thread..."); try Thread.sleep(20); catch (InterruptedException e) FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 6 thread.mystop(); Out.println("Thread has been stoped"); Out.print("Thread is alive: ); Out.println(thread.isAlive()); Programm-Ausgabe (Beispiel) Starting thread... Thread[Thread-0,5,main]: 1.. Thread[Thread-0,5,main]: 5 Thread has been stoped Thread is alive:true Thread[Thread-0,5,main]: 60 Unterbrechungsanforderungen Beispiel (interrupt und isinterrupted) Das richtige Mass für die Abfragehäufigkeit des Stop-Flags ist in der Praxis schwierig zu finden Wird Stop-Flag zu oft abgefragt, werden unnötig Ressourcen verbraucht Wird Stop-Flag zu selten abgefragt, ist die Zeit bis zum Stop zu lang Die Klasse Thread stellt hierfür folgende Methoden zur Verfügung interrupt() Setzt ein (Abbruch-)Flag, das eine Unterbrechungsanforderung signalisiert public boolean isinterrupted() Liefert true, wenn das Abbruch-Flag gesetzt ist public static boolean interrupted() Liefert den Status des Abbruch-Flags beim aktuellen Thread Entspricht dem Aufruf von currentthread().isinterrupted() und anschließendem Zurücksetzen des Abbruchflags auf initialen Wert false FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 7 public class ThreadInterrupt MyInterruptThread thread = new MyInterruptThread(); System.out.println("Starting thread..."); try Thread.sleep(100); catch (InterruptedException e) System.out.println("isAlive: +thread.isalive()); thread.interrupt(); System.out.println("isAlive: +thread.isalive()); class MyInterruptThread extends Thread int counter = 0; if (isinterrupted()) break; try Thread.sleep(10); catch (InterruptedException e) System.out.println(e); interrupt(); System.out.println(counter++); Abbruchflag wird zurückgesetzt Programm-Ausgabe Starting thread isalive: true 6 Java.lang.InterruptedException: sleep interrupted 7 isalive: false FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 8

3 Die Methode sleep Das Interface Runnable Mit Hilfe der folgenden Methoden kann ein Thread pausieren public static void sleep(long millis) Aktueller Prozeß wird für millis Millisekunden angehalten public static void sleep(long millis, int nanos) Aktueller Prozeß wird für millis Millisekunden und nanos Nanosekunden angehalten Tatsächliche Genauigkeit hängt von der Zielarchitektur ab Unter Windows ist es etwa 1ms sleep muss in einem try-catch Block gekapselt werden (kann während der Wartezeit eine Ausnahme vom Typ InterruptedException auslösen) Beim Starten eines Java-Programms wird automatisch ein Thread für die Ausführung des Hauptprogramms angelegt Die Methode sleep kann somit auch dazu verwendet werden das Hauptprogramm pausieren zu lassen Nicht alle Klassen, die als Thread laufen sollen, können von Thread abgeleitet werden Ist eine Klasse schon Bestandteil einer Vererbungshierarchie, kann sie nicht mehr von Thread abgeleitet werden (keine Mehrfachvererbung in Java) Anstatt einen Thread durch Ableiten der Klasse Thread, kann man ihn auch durch Implementieren der Interfaces Runnable erzeugen Das Interface Runnable enthält nur eine einzige Methode public abstract void run() Jede Klasse, deren Instanzen als Thread laufen sollen muss das Interface Runnable implementieren (auch Thread selbst) Um eine Instanz einer Klasse die Runnable implementiert als Thread laufen zu lassen muss man Ein neues Thread-Objekt erzeugen Konstruktor erhält Thread-Target Die Methode start() von Thread aufrufen C c = new C(); Thread t = new Thread(c); t.start(); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 10 Runnable (Beispiel) Wo ist der Fehler? class A public class RunnableExample class Count extends Thread public class CountThread int counter; long maxnumber; Instanz von B soll als Thread laufen public Count(long maxnumber) Count c = new Count(10); B b = new B(); this.maxnumber = maxnumber; c.start(); class B extends A B Kann nicht von Thread abgeleitet werden Thread thread = new Thread(b); System.out.println("Starting thread..."); for(long i=0; i<=maxnumber; i++) new Thread(c).start(); Count2 c2 = new Count2(10); counter = 0; while(true) Ruft die run-methode der Klasse B auf System.out.println("Int Count: "+i); c2.start(); new Thread(c2).start(); if (Thread.interrupted()) try break; Thread.sleep(200); class Count2 catch (InterruptedException e) long maxnumber; System.out.println(counter++); thread.interrupt(); System.out. println("thread has been stopped"); public Count2(long maxnumber) this.maxnumber = maxnumber; for (long i=0; i<=maxnumber; i++) Geht nicht da Count2 keine Methode start() kennt System.out.println("Int Count2: "+i); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 12

4 Synchronisationsprobleme class T1 extends Thread Person p; public T1(Person p) this.p = p; System.out.println(p.getName()); class T2 extends Thread Person p; public T2(Person p) this.p = p; p.setname("peter","barth"); p.setname("wolfgang","weitz"); class Person String name; String surname; setname(string n, String s) name = n; surname = s; FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 13 public String getname() return name + " " + surname; public class NameSync Person p = new Person(); T1 t1 = new T1(p); T2 t2 = new T2(p); t2.start(); t1.start(); Mögliche Programmausgaben Peter Barth Wolfgang Weitz Peter Weitz Wolfgang Barth Synchronisation mittels synchronized Um Threads zu synchronisieren gibt es in Java das Konzept des Monitors Ein Monitor kapselt einen kritischen Bereich (Programmteil, der nur von einem Programmteil auf einmal durchlaufen werden darf) mit Hilfe einer automatischen Sperre Sperre wird beim Betreten des Bereichts gesetzt Verlassen zurückgesetzt Ist die Sperre beim Eintritt in einen Monitor gesetzt, muss der aktuelle Prozeß warten, bis die Sperre freigegeben wird Das Monitor-Konzept wird in Java durch das Schlüsselwort synchronized realisiert Es kann eine komplette Methode oder ein Block innerhalb einer Methode geschützt werden public class SyncedThreads extends Thread static int counter = 0; Thread thread1 = new SyncedThreads(); Thread thread2 = new SyncedThreads(); thread1.start(); thread2.start(); try Thread.sleep(1000); catch (InterruptedException e) thread1.stop(); thread2.stop(); Mehrere Instanzen synchronized(getclass()) von SyncedThread System.out.println(counter++); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 14 Synchronisation von Methoden Animation public class SyncedFuncThread extends Thread int number; Thread thread1 = new SyncedFuncThread(10); Thread thread2 = new SyncedFuncThread(20); thread1.start(); thread2.start(); try Thread.sleep(2000); catch (InterruptedException e) thread1.stop(); thread2.stop(); public SyncedFuncThread(int n) number = n; for (int i = 0; i < 10; i++) Output.printRow(number); class Output static synchronized void printrow(int number) for (int i = 0; i < 10; i++) System.out.print(number + " "); int n = 0; double w; while (n < 10000) w = Math.sqrt(n++); System.out.println(); Ohne synchronized Mit synchronized Eine Animation ist das aufeinanderfolgende Anzeigen einer Sequenz von Einzelbildern Trägheit des menschlichen Auges sorgt für die Illusion einer zusammenhängenden Bewegung Probleme bei der Animation Einzelbilder müssen im richtigen Timing angezeigt werden Zu wenig Bilder pro Zeiteinheit führen zu ruckelnder Animation Sollen zu viele Bilder gezeichnet werden, können Bildteile verloren gehen Darstellung der Animation darf die Interaktivität eines Programms nicht beeinflussen Einzelbilder müssen mit Hilfe von Double-Buffering oder ähnlichen Techniken gezeichnet werden Naive Verwendung der paint/repaint-methoden von Java führt zu starkem Flackern FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 16

5 Animation in Java Einfach Animation (ohne eigenen Thread) Eine Animation kann in Java dadurch realisiert werden, dass in einer Schleife die Methode repaint wiederholt aufgerufen wird Aufruf von repaint führt zum internen Aufruf der paint-methode paint erzeugt dann das jeweils aktuelle Einzelbild Die Methode paint muss wissen, welches Bild bei welchem Aufruf erzeugt werden soll Meist wird hierzu ein Schleifenzähler verwendet, der das aktuelle Bild bezeichnet Nach der Ausführung von paint wartet der Aufrufer eine gewisse Zeitspanne Anschließend wird der Schleifenzähler erhöht und erneut paint aufgerufen Das ganze wird solange wiederholt, bis die Animation beendet ist FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 17 startanimation() public class SimpleAnim extends Frame int count = 0; paint(graphics g) SimpleAnim window = new SimpleAnim(); count = (count + 10) % getwidth(); g.fillrect(count, 175, 50, 50); try // 25 frames per second (fps) catch (InterruptedException e) public SimpleAnim() super("simple animation"); setbackground(color.blue); addwindowlistener(new WindowAdapter() windowclosing(windowevent e) ); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 18 Verwendung von Threads Einfach Animation (in eigenem Thread) Damit Programme, die Animationen enthalten, durch diese nicht komplett lahm gelegt werden, sollten alle repaint-schleifen in eigenen Threads laufen Zeitverzögerungen in die repaint-schleifen verlegt werden Haupt-Thread eines Animations-Programms hat dann genug Zeit, um die Bildschirmausgabe durchzuführen weitere Events zu bearbeiten public class AnimWThread extends Frame int x = 100, y = 10; int dx = 10, dy = 10; AnimWThread window = new AnimWThread(); startanimation() Thread thread = new Thread(this); try // 25 fps catch (InterruptedException e) Zur Verwendung mehrerer Threads muß die Fensterklasse das Interface Runnable implementieren Die Methode run() überschreiben eine Instanzvariable vom Typ Thread anlegen FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 1 public AnimWThread() paint(graphics g) super("simple animation with thread"); x +=dx; setbackground(color.yellow); if(x>getwidth()-50 x<0) dx = -dx; addwindowlistener(new WindowAdapter() y +=dy; if(y>getheight()-50 y<0) dy = -dy; g.fillrect(x, y, 50, 50); windowclosing(windowevent e) ); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 20

6 Reduzierung des Bildschirmflackerns Vor jedem Aufruf von paint wird zunächst der gesamte Inhalt des Fensters gelöscht Es erscheint somit kurz ein vollständig leerer Hintergrund Dies führt zu mehr oder weniger starkem Flackern der Animation Bildschirmflackern kann unterschiedlich unterdrückt werden 1. Bildschirm nicht löschen (nur bei nicht bewegten Animationen möglich) Aufruf von repaint ruft zunächst die Methode update der Klasse Component update(graphics g) g.setcolor(getbackground()); g.fillrect(0,0,width,height); g.setcolor(getforeground()); paint(g); Ersetzen durch update(graphics g) paint(g); 2. Nur den wirklich benötigen Bildschirmteil löschen und neu zeichnen 3. Double-Buffering (im Hintergrund zeichnen, fertige Zeichnung anzeigen) FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke Bildschirm nicht löschen public class AnimWThread extends Frame int x = 100, y = 10; int dx = 10, dy = 10; AnimWThread window = new AnimWThread(); startanimation() Thread thread = new Thread(this); try // 25 fps catch (InterruptedException e) paint(graphics g) x +=dx; if(x>getwidth()-50 x<0) dx = -dx; y +=dy; if(y>getheight()-50 y<0) dy = -dy; g.fillrect(x, y, 50, 50); public AnimWThread() super("simple animation with thread + (without clearing the frame) ); setbackground(color.yellow); addwindowlistener(new WindowAdapter() windowclosing(windowevent e) update(graphics g) paint(g); ); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke Bildschirm nicht löschen 2. Nur den benötigten Bereich löschen Bei bewegten Animationen kann es sinnvoll sein, nur die Teile des Bildschirms zu löschen, die im aktuellen Animationsschritt leer sind im vorangegangenen Schritt Grafikelemente enthielten Hierzu wird wiederum das automatische Löschen des Bildschirms durch Überlagern der Methode update verhindert In jedem Animationsschritt müssen alle benötigten Informationen über den vorangegangenen Schritt vorhanden sein Die Applikation muss sich dann selbst um das Löschen der relevanten Bildbereiche kümmern FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 24

7 2. Nur den benötigten Bereich löschen public class AnimWThread extends Frame int x = 100, y = 10; int dx = 10, dy = 10; AnimWThread window = new AnimWThread(); startanimation() Thread thread = new Thread(this); try // 25 fps catch (InterruptedException e) paint(graphics g) g.setcolor(getbackground()); g.fillrect(x, y, 50, 50); x +=dx; if(x>getwidth()-50 x<0) dx = -dx; y +=dy; if(y>getheight()-50 y<0) dy = -dy; g.setcolor(color.black); g.fillrect(x, y, 50, 50); public AnimWThread() super("simple animation with thread + (clear only part of the frame) ); setbackground(color.yellow); addwindowlistener(new WindowAdapter() windowclosing(windowevent e) update(graphics g) paint(g); ); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke Double-Buffering Double-Buffering ist ein universelles Mittel gegen Bildschirmflackern Bei jedem Animationsschritt werden zunächst alle Bildschirmausgaben in einen Buffer (Offscreen-Image) geschrieben Sind alle Ausgaben abgeschlossen, wir das Offscreen-Image auf die Fensteroberfläche kopiert 1. Zeichnen Graphics 2. Kopieren Offscreen-Image Offscreen-Image Prinzipelle Funktionsweise des Double-Bufferings in Java Ein Fensterobjekt beschafft sich durch Aufruf der Methode createimage ein Offscreen-Image und speichert es in einer Instanzvariablen Mittels getgraphics erhält man einen Grafikkontext zu dem Image Alle Bildschirmausgaben erfolgen auf den Offscreen-Grafikkontext Bildschirm Bildschirm Sind alle Ausgabeoperationen abgeschlossen, wird das Offscreen-Image mittels drawimage in das Ausgabefenster kopiert FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 26 Erweitern der Klasse Frame Eine Klasse DoubleBufferFrame Double-Buffering läßt sich in Java komplett kapseln Hierzu leitet man von der Klasse Frame eine neue Klasse DoubleBufferingFrame ab Die neue Klasse enthält zwei private Membervariable dbimage enthält das Offscreen-Image dbgraphics enthält den Offscreen-Grafikkontext Zusätzlich muss die Methode update geeignet überschrieben werden In update wird paint mit dbgraphics als Argument aufgerufen paint sendet dann alle Grafikbefehle auf das Offscreen-Image Zum Schluß wird mittels g.drawimage(dbimage,0,0,this) das Offscreen- Image auf dem Bildschirm angezeigt Alle Klassen, die von DoubleBufferingFrame abgeleitet sind, unterstützen nun das Double-Buffering automatisch Damit können schon bestehende Programme nachträglich flackerfrei gemacht werden, ohne dass eine einzige Zeile der eigentlichen Ausgaberoutinen geändert werden muss FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 27 public class DoubleBufferFrame extends Frame update(graphics g) private Image dbimage; // Initialising double buffer private Graphics dbgraphics; if (dbimage == null resized) private boolean resized; resized = false; dbimage = createimage( public DoubleBufferFrame() this.getsize().width, addcl(); this.getsize().height); dbgraphics = dbimage.getgraphics(); public DoubleBufferFrame(String s) super(s); // Clear background addcl(); dbgraphics.setcolor(getbackground()); dbgraphics.fillrect(0, 0, Auf Änderung der Fenstergröße reagieren this.getsize().width, void addcl() this.getsize().height); addcomponentlistener( // Paint foreground new ComponentAdapter() dbgraphics.setcolor(getforeground()); paint(dbgraphics); componentresized(componentevent e) // Show offscreen resized = true; g.drawimage(dbimage, 0, 0, this); ); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 28

8 Animation mit Double-Buffering (Beispiel) Double-Buffering Beispiel public class DoubleBufferExample extends DoubleBufferFrame int xb = 100, yb = 100, xs = 150, ys = 150; int dx = 10, dy = 10, angle = 0; double rad; DBExample window = new DBExample(); public DoubleBufferExample() super("double-buffering example"); addwindowlistener(new WindowAdapter() windowclosing(windowevent e) ); try // 25 fps catch (InterruptedException e) angle = (angle + 10) % 360; rad = angle*math.pi/180; xb += dx; if (xb>getwidth()-70 xb<0) dx = -dx; yb += dy; if (yb>getheight()-70 yb<0) dy = -dy; xs = xb (int)(35*math.sin(rad)); ys = yb (int)(35*math.cos(rad)); startanimation() g.filloval(xs, ys, 20, 20); Thread thread = new Thread(this); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 2 paint(graphics g) g.setcolor(color.blue); g.filloval(xb, yb, 50, 50); g.setcolor(color.green); FH-Wiesbaden --- Medieninformatik --- SS Prof. Dr. Ulrich Schwanecke 30