9.2 Threads erzeugen

Für nebenläufige Programme in Java ist die Klasse Thread zuständig. Jeder Thread ist somit mit einem Exemplar dieser Klasse verbunden. Die von uns gewünschte, parallel auszuführende Aktivität programmieren wir in der Objektmethode run(). Wird der Thread gestartet, arbeitet es die run()-Programmzeilen parallel ab. Java bietet zur Programmierung von Threads zwei Möglichkeiten an, die wir nachfolgend vorstellen werden.

9.2.1 Threads über die Schnittstelle Runnable implementieren

Eine Klasse, deren Exemplare Programmcode parallel ausführen sollen, muss die Schnittstelle Runnable implementieren. Sie schreibt eine run()-Methode vor.

Listing 9.1 FirstThread.java, Teil 1

class DateThread implements Runnable
{
  public void run()
  {
    for ( int i = 0; i < 20; i++ )
      System.out.println( new Date() );
  }
}
class CounterThread implements Runnable
{
  public void run()
  {
    for ( int i = 0; i < 20; i++ )
      System.out.println( i );
  }
}

In der Methode run() wird der auszuführende Programmcode eingebettet. Das heißt, bei dem einen Thread ist in einer Schleife das Date-Objekt auszugeben und in dem anderen der Schleifenzähler.

9.2.2 Threads über Runnable starten

Nun reicht es nicht aus, einfach die run()-Methode einer Klasse direkt aufzurufen. Würden wir dies tun, dann wäre nichts nebenläufig, sondern wir würden einfach eine Methode sequenziell ausführen. Damit der Programmcode nebenläufig zur Applikation läuft, müssen wir ein Thread-Objekt erzeugen und dann den Thread explizit starten. Dazu übergeben wir dem Konstruktor der Klasse Thread eine Referenz auf das Runnable-Objekt und rufen start() auf. Nachdem start() für den Thread eine Ablaufumgebung geschaffen hat, ruft es dann selbstständig die Methode run() genau einmal auf. Läuft der Thread schon, so wirft ein zweiter Aufruf der start()-Methode eine IllegalThreadStateException aus.

Listing 9.2 FirstThread.java, Teil 2

public class FirstThread
{
  public static void main( String args[] )
  {
    Thread t1 = new Thread( new DateThread() );
    t1.start();

    Thread t2 = new Thread( new CounterThread() );
    t2.start();
  }

}

Beim Starten des Programms erfolgt eine Ausgabe auf dem Bildschirm, die etwa so aussehen kann:

Thu Jan 18 15:40:20 CET 2001
0
1
2
3
4
5
6
7
8
9
Thu Jan 18 15:40:20 CET 2001
10
...

Deutlich ist die Verzahnung der beiden Prozesse zu erkennen. Was allerdings auf den ersten Blick etwas merkwürdig wirkt, ist die erste Zeile des Datum-Threads und viele weitere Zeilen des Zähl-Threads. Dies hat jedoch nichts zu sagen und zeigt deutlich den Nichtdeterminismus bei Threads. Interpretiert werden kann dies jedoch durch die unterschiedlichen Zeiten, die für die Aufgaben »gib Datum aus« und »gib Zahl« nötig sind.

Automatisches Starten während der Erzeugung

Erst der Aufruf der start()-Methode lässt den Thread ablaufen. Etwas eleganter ist der Weg, dass das Objekt seinen eigenen Thread verwaltet, der im Konstruktor gestartet wird. Dann muss nur dort ein Thread-Objekt für die Runnable-Umgebung angelegt und die start()-Methode ausgeführt werden.

class DateThreadAutoStart implements Runnable
{
  DateThreadAutoStart()
  {
    new Thread( this ).start();
  }
  public void run()
  {
    for ( int i = 0; i < 20; i++ )
      System.out.println( new Date() );
  }
}

9.2.3 Die Klasse Thread erweitern

Da die Klasse Thread selbst die Schnittstelle Runnable implementiert und die run()-Methode mit leerem Programmcode bereitstellt, können wir auch Thread erweitern, wenn wir eigene parallele Aktivitäten programmieren wollen. Dann müssen wir kein Runnable-Exemplar mehr in den Konstruktor einfügen, denn wenn unsere Klasse Unterklasse von Thread ist, reicht ein Aufruf der geerbten Methode start(). Danach arbeitet das Programm direkt weiter, führt also kurze Zeit später die nächste Anweisung hinter start() aus. Dann lassen sich auch mehrere Exemplare der Thread-Klasse erzeugen.

Fassen wir die drei Schritte noch einmal zusammen:

Wir bilden eine Unterklasse von Thread.

Für ein Programmstück, das nebenläufig ablaufen soll, überschreiben wir die run()-Methode. run() darf keinen Parameter enthalten, wenn doch, stimmt die Signatur nicht mit der in der Oberklasse Thread überein und statt des Überschreibens gäbe es ein Überladen. Dann aber geschieht beim Starten des Threads nichts, weil die geerbte parameterlose (und leere) run()-Methode aufgerufen wird.

Damit der Thread und damit das Programm startet, rufen wir die Objektmethode start() auf. Sie veranlasst die Laufzeitumgebung, Ressourcen zur Verfügung zu stellen. start() ruft dann automatisch run() auf. start() kann von uns auch überschrieben werden, was aber nur selten sinnvoll beziehungsweise nötig ist. Wir müssen dann darauf achten, super.start() aufzurufen, damit der Thread wirklich losrennt.

Hier klicken, um das Bild zu Vergrößern

class DateThreadExtends extends Thread
{
  public void run()
  {
    for ( int i = 0; i < 20; i++ )
      System.out.println( new Date() );
  }
}

Der Startschuss fällt für den Thread wieder beim Aufruf von start().

Thread t = new DateThreadExtends();
t.start();

Oder auch ohne Zwischenspeicherung der Objektreferenz:

new DateThreadExtends().start();

Damit wir als Thread-Benutzer nicht erst die start()-Methode aufrufen müssen, kann ein Thread sich auch wieder selbst starten. Der Konstruktor enthält einfach den Methodenaufruf start().

class DateThreadExtends extends Thread
{
  DateThreadExtends()
  {
    start();
  }
  ...  der Rest bleibt ...
}

class java.lang.Thread
implements Runnable

void run() Diese Methode enthält den parallel auszuführenden Programmcode.

void start() Ein neuer Thread - neben dem die Methode aufrufenden Thread - wird gestartet. Der neue Thread führt die run()-Methode nebenläufig aus. Läuft der Thread schon, wird eine IllegalThreadStateException ausgelöst.

Was passiert, wenn wir statt start() nun run() aufrufen?

Ein Programmierfehler, der hin und wieder passiert, ist Folgender: Anstatt start() rufen wir aus Versehen run() auf. Was geschieht? Fast genau das Gleiche wie bei start(), nur mit dem Unterschied, dass die Objektmethode run() nicht parallel zum übrigen Programm abgearbeitet wird. Der aktuelle Thread bearbeitet die run()-Methode sequenziell, bis sie zu Ende ist und die Anweisungen nach dem Aufruf an die Reihe kommen. Der Fehler fällt nicht immer direkt auf, denn die Aktionen in run() finden ja statt - nur nicht nebenläufig.

Runnable ist kein Thread. Wie können wir die Thread-Methoden nutzen?

Eine Erweiterung der Klasse Thread hat den Vorteil, dass alle geerbten Methoden sofort genutzt werden können. Wenn wir Runnable implementieren, dann genießen wir den Vorteil nicht. Wie lassen sich dann trotzdem die Thread-Methoden nutzen? Dazu bietet Thread die Klassenmethode currentThread() an, um die Objektreferenz für das Thread-Exemplar zu holen, das gerade diese Methode ausführt.

System.out.println( Thread.currentThread().getPriority() );

9.2.4 Erweitern von Thread oder Implementieren von Runnable?

Eine unangenehme Begleiterscheinung des Erweiterns von Thread ist, dass die Möglichkeit der Vererbung nicht genutzt werden kann, wenn die neue Thread-Unterklasse noch weitere Funktionalität erben soll - Mehrfachvererbung ist in Java nicht möglich. Dies ist häufig das Dilemma, wenn ein Applet nebenläufige Programmstücke besitzt. Hier können allerdings innere Klassen das Problem lösen. Die Tabelle fasst die Vor- und Nachteile der beiden Alternativen noch einmal zusammen:

Tabelle 9.2 Vor- und Nachteile von extends Thread und implements Runnable