9.2 Threads erzeugen 

Für nebenläufige Programme in Java ist die Klasse Thread zuständig. Jeder Thread ist somit eng mit einem Exemplar dieser Klasse verbunden. Die von uns gewünschte, parallel auszuführende Aktivität programmieren wir in der Objektmethode run(). Wird das Thread-Objekt 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, die eine run()-Methode vorschreibt.

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 in einer Schleife das Date-Objekt auszugeben und in dem anderen die lokale Variable der Schleife.

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 die 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.

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 erweitern die Klasse Thread mit oder in einer neuen Unterklasse.

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.

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 als letzte Anweisung 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 Operationen 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 – denn Mehrfachvererbung ist in Java ja 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: