11.3 Die Zustände eines Threads

Bei einem Thread-Exemplar können wir einige Zustände feststellen:

Zustand über Thread.State

In welchem Zustand ein Thread gerade ist, zeigt die Methode getState(). Sie liefert ein Objekt vom Typ der Aufzählung Thread.State – die einzige im Paket java.lang –, die definiert:

Zudem lässt sich die Methode isAlive() verwenden, die erfragt, ob der Thread gestartet wurde, aber noch nicht tot ist.

11.3.1 Threads schlafen

Manchmal ist es notwendig, einen Thread eine bestimmte Zeit lang anzuhalten. Dazu lassen sich Methoden zweier Klassen nutzen:

• Die überladene Funktion Thread.sleep(). Etwas erstaunlich ist sicherlich, dass sie keine Objektmethode von einem Thread-Objekt ist, sondern eine statische Funktion. Ein Grund wäre, dass dadurch verhindert wird, externe Threads zu beeinflussen. Es ist nicht möglich, einen fremden Thread, über dessen Referenz wir verfügen, einfach einige Sekunden lang schlafen zu legen und ihn so von der Ausführung abzuhalten.

• Die Objektmethode sleep() auf einem TimeUnit-Objekt. Auch sie bezieht sich immer auf den ausführenden Thread. Der Vorteil gegenüber sleep() ist, dass hier die Zeiteinheiten besser sichtbar sind.

try { 
  Thread.sleep( 2000 ); 
} catch ( InterruptedException e ) { }

try {

  TimeUnit.SECONDS.sleep( 2 ); 
} catch ( InterruptedException e ) { }

Die Unterbrechung sitzt in einem zwingenden try-catch-Block, da eine InterruptedException ausgelöst wird, wenn der Thread unterbrochen wird – etwa durch interrupt() –, und diese keine RuntimeException ist.

Praktisch wird das Erweitern der Klasse Thread bei inneren anonymen Klassen. Die folgende Anweisung gibt nach zwei Sekunden Schlafzeit eine Meldung auf dem Bildschirm aus.

Listing 11.5 com/tutego/insel/thread/SleepInInnerClass.java, main()

new Thread() { 
  @Override public void run() { 
    try { 
      Thread.sleep( 2000 ); 
      System.out.println( "Zeit ist um." ); 
    } catch ( InterruptedException e ) { e.printStackTrace(); } 
  } 
}.start();

Da new Thread(){...} ein Exemplar der anonymen Unterklasse ergibt, lässt die auf dem Ausdruck aufgerufene Objektmethode start() den Thread gleich loslaufen. Aufgaben dieser Art lösen auch die Timer gut.

class java.lang.Thread 
implements Runnable

• static void sleep( long millis ) throws InterruptedException
  Der aktuell ausgeführte Thread wird mindestens millis Millisekunden eingeschläfert. Unterbricht ein anderer Thread den schlafenden, wird vorzeitig eine InterruptedException ausgelöst.

• static void sleep( long millis, int nanos ) throws InterruptedException
  Der aktuell ausgeführte Thread wird mindestens millis Millisekunden und zusätzlich nanos Nanosekunden eingeschläfert. Im Gegensatz zu sleep(long) wird bei einer negativen Millisekundenanzahl eine IllegalArgumentException ausgelöst; auch wird diese Exception ausgelöst, wenn die Nanosekundenanzahl nicht zwischen 0 und 999.999 liegt.

enum java.util.concurrent.TimeUnit 
extends Enum<TimeUnit> 
implements Serializable, Comparable<TimeUnit>

• NANOSECONDS, MICROSECONDS, MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS
  Aufzählungselemente von TimeUnit.

• void sleep( long timeout ) throws InterruptedException
  Führt ein Thread.sleep() für die Zeiteinheit aus.

Eine überladene Funktion Thread.sleep(TimeUnit, long) wäre praktisch, gibt es aber nicht!

11.3.2 Mit yield() auf Rechenzeit verzichten

Neben sleep() gibt es eine weitere Methode, um kooperative Threads zu programmieren: die Methode yield(). Sie funktioniert etwas anders als sleep(), da hier nicht nach Ablauf der genannten Millisekunden zum Thread zurückgekehrt wird, sondern yield() den Thread bezüglich seiner Priorität wieder in die Thread-Warteschlange des Systems einordnet. Einfach ausgedrückt, sagt yield() der Thread-Verwaltung: »Ich setze diese Runde aus und mache weiter, wenn ich das nächste Mal dran bin.«

class java.lang.Thread 
implements Runnable

• static void yield()
  Der laufende Thread gibt freiwillig seine Rechenzeit ab. Die Methode ist für Implementierungen der JVM nicht verbindlich.

11.3.3 Das Ende eines Threads

Es gibt Threads, die dauernd laufen, weil sie zum Beispiel Serverfunktionen implementieren. Andere Threads führen einmalig eine Operation aus und sind danach beendet. Allgemein ist ein Thread beendet, wenn eine der folgenden Bedingungen zutrifft:

• Die run()-Methode wurde ohne Fehler beendet. Wenn wir eine Endlosschleife programmieren, würde diese potenziell einen nie endenden Thread bilden.

• In der run()-Methode tritt eine RuntimeException auf, die die Methode beendet. Das beendet weder die anderen Threads noch die JVM als Ganzes.

• Der Thread wurde von außen abgebrochen. Dazu dient die prinzipbedingt problematische Methode stop(), von deren Verwendung abgeraten wird und die auch veraltet ist.

• Die virtuelle Maschine wird beendet und nimmt alle Threads mit ins Grab.

Wenn der Thread einen Fehler melden soll

Da ein Thread nebenläufig arbeitet, kann die run()-Methode synchron schlecht Exceptions melden oder einen Rückgabewert liefern. Wer sollte auch an welcher Stelle darauf hören? Eine Lösung für das Problem ist ein Listener, der sich beim Thread anmeldet und darüber informiert wird, ob der Thread seine Arbeit machen konnte oder nicht. Eine andere Lösung gibt Callable, mit dem ein spezieller Fehlercode zurückgegeben oder eine Exception angezeigt werden kann. Speziell für ungeprüfte Ausnahmen kann ein UncaughtExceptionHandler weiterhelfen.

11.3.4 UncaughtExceptionHandler für unbehandelte Ausnahmen

Einer der Gründe für das Ende eines Threads ist eine unbehandelte Ausnahme, etwa von einer nicht aufgefangenen RuntimeException. Um in diesem Fall einen kontrollierten Abgang zu ermöglichen, lässt sich an den Thread ein UncaughtExceptionHandler hängen, der immer dann benachrichtigt wird, wenn der Thread wegen einer nicht behandelten Ausnahme endet.

UncaughtExceptionHandler ist eine in Thread definierte innere Schnittstelle, die eine Operation void uncaughtException(Thread t, Throwable e) vorschreibt. Eine Implementierung der Schnittstelle lässt sich entweder einem individuellen Thread oder allen Threads anhängen, sodass im Fall des Abbruchs durch unbehandelte Ausnahmen die JVM die Methode uncaughtException() aufruft. Auf diese Weise kann die Applikation im letzten Atemzug noch den Fehler loggen, den die JVM über das Throwable e übergibt.

class java.lang.Thread 
implements Runnable

• void setUncaughtExceptionHandler( Thread.UncaughtExceptionHandler eh )
  Setzt den UncaughtExceptionHandler für den Thread.

• Thread.UncaughtExceptionHandler getUncaughtExceptionHandler()
  Liefert den aktuellen UncaughtExceptionHandler.

• static void setDefaultUncaughtExceptionHandler( Thread.UncaughtExceptionHandler eh ) Setzt den UncaughtExceptionHandler für alle Threads.

• static Thread.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler()
  Liefert den zugewiesenen UncaughtExceptionHandler aller Threads.

Ein mit setUncaughtExceptionHandler() lokal gesetzter UncaughtExceptionHandler überschreibt den Eintrag für den setDefaultUncaughtExceptionHandler(). Zwischen dem mit dem Thread assoziierten Handler und dem globalen gibt es noch einen Handler-Typ für Thread-Gruppen, der jedoch seltener verwendet wird. (Vor Java 5 war er jedoch die einzige Möglichkeit, das Ende zu erkennen.)

11.3.5 Einen Thread höflich mit Interrupt beenden

Der Thread ist in der Regel zu Ende, wenn die run()-Methode ordentlich bis zum Ende ausgeführt wurde. Enthält eine run()-Methode jedoch eine Endlosschleife – wie etwa bei einem Server, der auf eingehende Anfragen wartet –, so muss der Thread von außen zur Kapitulation gezwungen werden. Die naheliegende Möglichkeit, mit der Thread-Methode stop() einen Thread abzuwürgen, wollen wir im Abschnitt 11.3.6 diskutieren.

Wenn wir den Thread schon nicht von außen beenden wollen, können wir ihn bitten, seine Arbeit aufzugeben. Periodisch müsste er dann nur überprüfen, ob jemand von außen den Abbruchswunsch geäußert hat.

Die Methoden interrupt() und isInterrupted()

Die Methode interrupt() setzt von außen in einem Thread-Objekt ein internes Flag, das dann in der run()-Methode durch isInterrupted() periodisch abgefragt werden kann.

Das folgende Programm soll jede halbe Sekunde eine Meldung auf dem Bildschirm ausgeben. Nach zwei Sekunden wird der Unterbrechungswunsch mit interrupt() gemeldet. Auf dieses Signal achtet die sonst unendlich laufende Schleife und bricht ab.

Listing 11.6 com/tutego/insel/thread/ThreadusInterruptus.java, main()

Thread t = new Thread() 
{ 
  @Override 
  public void run() 
  { 
    System.out.println( "Es gibt ein Leben vor dem Tod.  " ); 
 
    while ( ! isInterrupted() ) 
    { 
      System.out.println( "Und er läuft und er läuft und er läuft" ); 
 
      try 
      { 
       Thread.sleep( 500 ); 
      } 
      catch ( InterruptedException e ) 
      { 
       interrupt(); 
       System.out.println( "Unterbrechung in sleep()" ); 
      } 
    } 
 
    System.out.println( "Das Ende" ); 
  } 
}; 
t.start(); 
Thread.sleep( 2000 ); 
t.interrupt();

Die Ausgabe zeigt hübsch die Ablaufsequenz:

Es gibt ein Leben vor dem Tod. 
Und er läuft und er läuft und er läuft 
Und er läuft und er läuft und er läuft 
Und er läuft und er läuft und er läuft 
Und er läuft und er läuft und er läuft 
Unterbrechung in sleep() 
Das Ende

Die run()-Methode im Thread ist so implementiert, dass die Schleife genau dann verlassen wird, wenn isInterrupted() den Wert true ergibt, also von außen die interrupt()-Methode für dieses Thread-Exemplar aufgerufen wurde. Genau dies geschieht in der main()-Methode. Auf den ersten Blick ist das Programm leicht verständlich, doch vermutlich erzeugt das interrupt() im catch-Block die Aufmerksamkeit. Stünde diese Zeile dort nicht, würde das Programm aller Wahrscheinlichkeit nach nicht funktionieren. Das Geheimnis ist folgendes: Wenn die Ausgabe nur jede halbe Sekunde stattfindet, befindet sich der Thread fast die gesamte Zeit über in der Schlafmethode sleep(). Also wird vermutlich der interrupt() den Thread gerade beim Schlafen stören. Genau dann wird sleep() durch InterruptedException unterbrochen, und der catch-Behandler fängt die Ausnahme ein. Jetzt passiert aber etwas Unerwartetes: Durch die Unterbrechung wird das interne Flag zurückgesetzt, sodass isInterrupted() meint, die Unterbrechung habe gar nicht stattgefunden. Daher muss interrupt() erneut aufgerufen werden, da das Abbruch-Flag neu gesetzt werden muss und isInterrupted() das Ende bestimmen kann.

Wenn wir mit der Objektmethode isInterrupted() arbeiten, müssen wir beachten, dass neben sleep() auch die Methoden join() und wait() durch die InterruptedException das Flag löschen.

Zusammenfassung: interrupted(), isInterrupted() und interrupt()

Die Methodennamen sind verwirrend gewählt, sodass wir die Aufgaben noch einmal zusammenfassen wollen: Die Objektmethode interrupt() setzt in einem (anderen) Thread-Objekt ein Flag, dass es einen Antrag gab, den Thread zu beenden. Sie beendet aber den Thread nicht, obwohl es der Methodenname nahelegt. Dieses Flag lässt sich mit der Objektmethode isInterrupted() abfragen. In der Regel wird dies innerhalb einer Schleife geschehen, die darüber bestimmt, ob die Aktivität des Threads fortgesetzt werden soll. Die statische Methode interrupted() ist zwar auch eine Anfragemethode und testet das entsprechende Flag des aktuell laufenden Threads, wie Thread.currentThread().isInterrupted(), aber zusätzlich löscht es den Interrupt-Status auch, was isInterrupted() nicht tut. Zwei aufeinanderfolgende Aufrufe von interrupted() führen daher zu einem false, es sei denn, in der Zwischenzeit erfolgt eine weitere Unterbrechung.

11.3.6 Der stop() von außen und die Rettung mit ThreadDeath

Wenn ein Thread nicht auf interrupt() hört, aber aus irgendwelchen Gründen dringend beendet werden muss, müssen wir wohl oder übel die veraltete Methode stop() einsetzen.

Dass die Methode stop() veraltet ist, zeigen eine unterschlängelte Linie und ein Symbol am linken Rand an. Steht der Cursor auf der problematischen Zeile, zeigt eine Fehlermeldung ebenfalls das Problem.

deprecated gibt uns schon einen guten Hinweis darauf, stop() besser nicht zu benutzen. (Leider gibt es hier, im Gegensatz zu den meisten anderen veralteten Methoden, keinen einfachen, empfohlenen Ersatz.) Überschreiben können wir stop() auch nicht, da es final ist. Wenn wir einen Thread von außen beenden, geben wir ihm keine Chance mehr, seinen Zustand konsistent zu verlassen. Zudem kann die Unterbrechung an beliebiger Stelle erfolgen, sodass angeforderte Ressourcen frei in der Luft hängen können.

class java.lang.Thread 
implements Runnable

• final void stop()
  Wurde der Thread gar nicht gestartet oder ist er bereits abgearbeitet beziehungsweise beendet, kehrt die Methode sofort zurück. Andernfalls wird über checkAccess() geprüft, ob wir überhaupt das Recht haben, den Thread abzuwürgen. Dann wird der Thread beendet, egal was er zuvor unternommen hat; jetzt kann er nur noch sein Testament in Form eines ThreadDeath-Objekts als Exception anzeigen.

Das ThreadDeath-Objekt

So unmöglich ist das Reagieren auf ein stop() auch nicht. Immer dann, wenn ein Thread mit stop() zum Ende kommen soll, löst die JVM eine ThreadDeath-Ausnahme aus, die letztendlich den Thread beendet. ThreadDeath ist eine Unterklasse von Error, das wiederum von Throwable abgeleitet ist, sodass ThreadDeath mit einem try-catch-Block abgefangen werden kann. Die Java-Entwickler haben ThreadDeath nicht zu einer Unterklasse von Exception gemacht, weil sie nicht wollten, dass ThreadDeath bei einer allgemeinen Exception-Behandlung über catch(Exception e) abgefangen wird. (Dass wir die Klasse überhaupt nutzen können, ist einem Fehler von Sun zuzuschreiben. Die Klasse sollte eigentlich nicht sichtbar sein.)

Wenn wir ThreadDeath auffangen, können wir noch auf den Tod reagieren und Aufräumarbeiten erlauben. Wir sollten aber nicht vergessen, anschließend das aufgefangene ThreadDeath-Objekt wieder auszulösen, weil der Thread sonst nicht beendet wird.

Listing 11.7 com/tutego/insel/thread/ThreadStopRecovery.java, main()

Thread t = new Thread() 
{ 
  @Override public void run() 
  { 
    try 
    { 
      while ( true ) System.out.println( "I Like To Move It." ); 
    } 
    catch ( ThreadDeath td ) 
    { 
      System.out.println( "Das Leben ist nicht tot zu kriegen." ); 
      throw td; 
    } 
  } 
}; 
t.start(); 
try { Thread.sleep( 1 ); } catch ( Exception e ) { } 
t.stop();

ThreadDeath bietet eine extravagante Möglichkeit, um das aktuell laufende Programm zu beenden: throw new ThreadDeath(). Die Anweisung System.exit() ist aber weniger aufsehenerregend.

11.3.7 Ein Rendezvous mit join()

Wollen wir Aufgaben auf mehrere Threads verteilen, kommt der Zeitpunkt, an dem die Ergebnisse eingesammelt werden. Die Resultate können allerdings erst dann zusammengebracht werden, wenn alle Threads mit ihrer Ausführung fertig sind. Da sie sich zu einem bestimmten Zeitpunkt treffen, heißt das auch Rendezvous.

Zum Warten gibt es mehrere Strategien. Zunächst lässt sich mit Callable arbeiten, um dann mit get() synchron auf das Ende zu warten. Arbeiten wir mit Runnable, so kann ein Thread keine direkten Ergebnisse wie eine Methode nach außen geben, weil die run()-Methode den Ergebnistyp void hat. Da ein nebenläufiger Thread zudem asynchron arbeitet, wissen wir nicht einmal, wann wir das Ergebnis erwarten können.

Die Übertragung von Werten ist kein Problem. Hier können Klassenvariablen und auch Objektvariablen helfen, denn über sie können wir kommunizieren. Jetzt fehlt nur noch, dass wir auf das Ende der Aktivität eines Threads warten können. Das funktioniert mit der Methode join().

In unserem folgenden Beispiel legt ein Thread t in der Variable result ein Ergebnis ab. Wir können die Auswirkungen von join() sehen, wenn wir die auskommentierte Zeile hineinnehmen.

Listing 11.8 com/tutego/insel/thread/JoinTheThread.java

package com.tutego.insel.thread; 
 
class JoinTheThread 
{ 
  static class JoinerThread extends Thread 
  { 
    public int result; 
 
    @Override public void run() 
    { 
      result = 1; 
    } 
  } 
 
  public static void main( String[] args ) throws InterruptedException 
  { 
    JoinerThread t = new JoinerThread(); 
    t.start(); 
//    t.join(); 
    System.out.println( t.result ); 
  } 
}

Ohne den Aufruf von join() wird als Ergebnis 0 ausgegeben, denn das Starten des Threads kostet etwas Zeit. In dieser Zeit geben wir aber die automatisch auf 0 initialisierte Klassenvariable aus. Nehmen wir join() hinein, wird die run()-Methode zu Ende ausgeführt, und der Thread setzt die Variable result auf 1. Das sehen wir dann auf dem Bildschirm.

class java.lang.Thread 
implements Runnable

• final void join() throws InterruptedException
  Der aktuell ausgeführte Thread wartet auf den Thread, für den die Methode aufgerufen wird, bis dieser beendet ist.

• final void join( long millis ) throws InterruptedException
  Wie join(), doch wartet diese Variante höchstens millis Millisekunden. Wurde der Thread bis dahin nicht vollständig beendet, fährt das Programm fort. Auf diese Weise kann versucht werden, innerhalb einer bestimmten Zeitspanne auf den Thread zu warten, sonst aber weiterzumachen. Ist millis gleich 0, so hat dies die gleiche Wirkung wie join().

• final void join ( long millis, int nanos ) throws InterruptedException
  Wie join(long), jedoch mit potenziell genauerer Angabe der maximalen Wartezeit.

Nach einem thread.join(long) ist mitunter die thread.isAlive()-Methode nützlich, denn sie sagt aus, ob thread noch aktiv arbeitet oder beendet ist.

Warten auf den Langsamsten

Große Probleme lassen sich in mehrere Teile zerlegen, und jedes Teilproblem kann dann von einem Thread gelöst werden. Dies ist insbesondere bei Mehrprozessorsystemen eine lohnenswerte Investition. Zum Schluss müssen wir nur noch darauf warten, dass die Threads zum Ende gekommen sind, und das Ergebnis einsammeln. Dazu eignet sich join() gut.

Thread a = new AThread(); 
Thread b = new BThread(); 
a.start(); 
b.start(); 
a.join(); 
b.join();

Es ist unerheblich, wessen join() wir zuerst aufrufen, da wir ohnehin auf den langsamsten Thread warten müssen. Wenn ein Thread schon beendet ist, kehrt join() sofort zurück.

Eine andere Lösung für zusammenlaufende Threads besteht darin, diese in einer Thread-Gruppe zusammenzufassen. Dann können sie zusammen behandelt werden, sodass nur das Ende der Thread-Gruppe beobachtet wird.

11.3.8 Barrier und Austausch mit Exchanger

Der Punkt, an dem alle Threads zusammenkommen und sich die Ergebnisse zusammenlegen lassen, heißt auf Englisch barrier. Seit Java 5 gibt es die Klasse CyclicBarrier im Paket java.util.concurrent, die eine solche Barriere realisiert. Der Vorteil gegenüber join() besteht in der Tatsache, dass der für die Abarbeitung verwendete Thread nicht enden muss – und ein Thread im Thread-Pool endet eigentlich nicht –, sondern dass er mit await() sein »Bin-fertig«-Signal geben kann. Das Buch-Beispiel com/tutego/insel/thread/concurrent/ArraySummer.java, das im Netz und auf der DVD zu finden ist, zeigt anhand eines parallelen Summierers die Funktionsweise.

Stop and go mit Exchanger

Die Klasse java.util.concurrent.Exchanger<V> dient ebenfalls dem Zusammenkommen von Threads, die jedoch bei ihrem Rendezvous Daten austauschen können. Ein üblicher Fall betrifft das Füllen von Puffern, etwa wenn ein Thread Daten vom Datensystem liest und ein anderer Thread die Daten über das Netzwerk weiterschickt. Ein Dateisystem-Thread füllt den Puffer, und wenn er komplett gefüllt ist, trifft er sich mit einem anderen Netzwerk-Thread, dem er den vollen Puffer gibt und von dem er wieder einen leeren Puffer empfängt. Der Netzwerk-Thread kann dann den Inhalt des Puffers wieder »verbrauchen« und der erste Thread den Puffer wieder mit Daten vom Dateisystem füllen.

11.3.9 Arbeit niederlegen und wieder aufnehmen

Wollen wir erreichen, dass ein Thread für eine bestimmte Zeit die Arbeit niederlegt und ein anderer den schlafenden Thread wieder aufwecken kann, müssten wir das selbst implementieren. Zwar gibt es mit suspend() und resume() zwei Methoden, doch sind sie veraltet, da sie ähnlich problematisch sind wie stop().

class java.lang.Thread 
implements Runnable

• final void suspend()
  Haben wir die Möglichkeit, auf den Thread zuzugreifen (checkAccess() regelt dies wieder), und der Thread lebt, wird er so lange eingefroren (schlafen gelegt), bis resume() aufgerufen wird.

• final void resume()
  Weckt einen durch suspend() lahmgelegten Thread wieder auf, der dann wieder arbeiten kann.

11.3.10 Priorität

Jeder Thread verfügt über eine Priorität, die aussagt, wie viel Rechenzeit ein Thread relativ zu anderen Threads erhält. Die Priorität ist eine Zahl zwischen Thread.MIN_PRIORITY (1) und Thread.MAX_PRIORITY (10). Durch den Wert kann der Scheduler erkennen, welchem Thread er den Vorzug geben soll, wenn mehrere Threads auf Rechenzeit warten. Bei seiner Initialisierung bekommt jeder Thread die Priorität des erzeugenden Threads. Normalerweise ist es die Priorität Thread.NORM_PRIORITY (5).

Das Betriebssystem (oder die JVM) nimmt die Threads immer entsprechend der Priorität aus der Warteschlange heraus (daher Prioritätswarteschlange). Ein Thread mit der Priorität N wird vor allen Threads mit der Wichtigkeit kleiner N, aber hinter denen der Priorität größer gleich N gesetzt. Ruft nun ein kooperativer Thread mit der Priorität N die Methode yield() auf, bekommt ein Thread mit der Priorität <= N auch eine Chance zur Ausführung.

Die Priorität kann durch Aufruf von setPriority() geändert und mit getPriority() abgefragt werden. Allerdings macht Java nur sehr schwache Aussagen über die Bedeutung und Auswirkung von Thread-Prioritäten.

t.setPriority( Thread.MAX_PRIORITY );

class java.lang.Thread 
implements Runnable

• final int getPriority()
  Liefert die Priorität des Threads.

• final void setPriority( int newPriority )
  Setzt die Priorität des Threads. Es ergibt eine IllegalArgumentException, wenn die Priorität nicht zwischen MIN_PRIORITY (1) und MAX_PRIORITY (10) liegt.

Granularität und Vorrang

Die zehn Prioritätsstufen garantieren nicht zwingend unterschiedliche Ausführungen. Obwohl anzunehmen ist, dass ein Thread mit der Priorität NORM_PRIORITY+1 häufiger Programmcode ausführt als ein Thread mit der Priorität NORM_PRIORITY, kann ein Betriebssystem dies anders implementieren. Nehmen wir an, die Plattform implementiert lediglich fünf Prioritätsstufen. Ist 1 die niedrigste Stufe und 5 die höchste – die mittlere Stufe ist 3 –, werden wahrscheinlich NORM_PRIORITY und NORM_PRIORITY + 1 auf die Stufe 3 transformiert und haben demnach dieselbe Priorität. Was wir daraus lernen: Auch bei unterschiedlichen Prioritäten können wir nicht erwarten, dass ein bestimmtes Programmstück zwingend schneller läuft. Zudem gibt es Betriebssysteme mit Schedulern, die keine Prioritäten unterstützen oder diese unerwartet interpretieren.

11.3.11 Der Thread als Dämon

Ein Server reagiert oft in einer Endlosschleife auf eingehende Aufträge vom Netzwerk und führt die gewünschte Aufgabe aus. In unseren bisherigen Programmen haben wir oft Endlosschleifen eingesetzt, sodass ein gestarteter Thread nie beendet wird. Wenn also run(), wie in den vorangehenden Beispielen, nie abbricht (Informatiker sprechen hier von terminiert), läuft der Thread immer weiter, auch wenn die Hauptapplikation beendet ist. Dies ist nicht immer beabsichtigt, da vielleicht Server-Funktionalität nach Beenden der Applikation nicht mehr gefragt ist. Dann sollte auch der endlos laufende Thread beendet werden. Um dies auszudrücken, erhält ein im Hintergrund arbeitender Thread eine spezielle Kennung: Der Thread wird als Dämon [Das griechische Wort (engl. daemon) bezeichnet allerlei Wesen zwischen Gott und Teufel.] gekennzeichnet. Standardmäßig ist ein aufgebauter Thread kein Dämon.

Ein Dämon ist wie ein Heinzelmännchen im Hintergrund mit einer Aufgabe beschäftigt. Wenn das Hauptprogramm beendet ist und die Laufzeitumgebung erkennt, dass kein normaler Thread läuft, sondern nur Dämonen, dann ist das Ende für die Dämonen eingeläutet. Das ist wie bei den Göttern der Scheibenwelt: Glaubt keiner an sie, hören sie auf zu existieren, obwohl der Dämon-Thread noch nicht terminiert hat. Wir müssen uns also um das Ende des Dämons nicht kümmern. Das ist etwa bei Überwachungsaufgaben ganz praktisch. Wenn es nichts mehr zu überwachen gibt, kann sich auch der Dämon in Luft auflösen.

Einen Thread in Java als Dämon zu kennzeichnen, heißt, die Methode setDaemon() mit dem Argument true aufzurufen. Die Methode ist nur vor dem Starten des Threads erlaubt. Danach kann der Status nicht wieder vom Dämon in den normalen Benutzer-Thread umgesetzt werden. Die Auswirkungen von setDaemon(true) können wir am folgenden Programm ablesen:

Listing 11.9 com/tutego/insel/thread/DaemonThread.java

package com.tutego.insel.thread; 
 
class DaemonThread extends Thread 
{ 
  DaemonThread() 
  { 
    setDaemon( true ); 
  } 
 
  @Override 
  public void run() 
  { 
    while ( true ) 
      System.out.println( "Lauf, Thread, lauf" ); 
  } 
 
  public static void main( String[] args ) 
  { 
    new DaemonThread().start(); 
  } 
}

In diesem Programm wird der Thread gestartet, und danach ist die Anwendung sofort beendet. Vor dem Ende kann der neue Thread aber schon einige Zeilen auf der Konsole ausgeben. Klammern wir die Anweisung mit setDaemon(true) aus, läuft das Programm ewig, da die Laufzeitumgebung auf das natürliche Ende der Thread-Aktivität wartet.

class java.lang.Thread 
implements Runnable

• final void setDaemon( boolean on )
  Markiert den Thread als Dämon oder normalen Thread.

• final boolean isDaemon()
  Testet, ob der Thread ein Dämon-Thread ist.

AWT und Dämonen

Obwohl Dämonen für Hintergrundaufgaben eine gute Einrichtung sind, ist der AWT-Thread kein Dämon. Unterschiedliche AWT-Threads sind normale Benutzer-Threads, dazu gehören AWT-Input, AWT-Motif oder Screen_Updater. Dies bedeutet, dass bei einmaliger Nutzung einer AWT-Funktion ein spezieller Nicht-Dämon-Thread gestartet wird, sodass die Applikation nicht automatisch beendet wird, wenn das Hauptprogramm endet. Daher muss in vielen Fällen die Applikation hart mit System.exit() beendet werden.

Ihr Kommentar