Threads in Java

Es ist sehr einfach in Java einen Thread zu erzeugen, ihn zu starten, stoppen, pausieren und fortzusetzen. Dazu gibt es eine Klasse Threads (in java.lang.threads), die Threads implementiert. Wir picken hier die wichtigsten Elemente der vollständigen Beschreibung dieser Klasse heraus:

public  class  java.lang.Thread
    extends  java.lang.Object
    implements java.lang.Runnable
{
    // Unvollstaendiger Auszug aus der Klassendeklaration !!
 
        // Constructors
    public Thread();
    public Thread(Runnable  target);
 
        // Methods
    public void run();
    public void start();
    public final void stop();
    public final void suspend();
    public final void resume();
}

Der Konstruktor Thread() erzeugt erwartungsgemäss eine neue Instanz der Klasse Thread. Wie der zweite Konstruktor Thread(Runnable target) verwendet wird, werden Sie im nächsten Abschnitt sehen. Die Methode run() enthält den Programmcode, der als Thread abgearbeitet wird. Selbstverständlich kann run() auch andere Methoden aufrufen, die dann immer noch im gleichen Thread ablaufen. start() startet einen Thread, stop() beendet dessen Ausführung. suspend() unterbricht die Ausführung, die dann mit resume() wieder fortgesetzt werden kann.

Erweitern der Thread Klasse

Eine Möglichkeit einen Thread zu erzeugen besteht natürlich darin, eine Unterklasse von Thread abzuleiten:

public  class  meinThread
    extends java.lang.Thread
{
    public void run() {
      . . .  // hier steht der Code der als Thread abgearbeitet wird
    }
}
 

Das ist tatsächlich schon die ganze Implementation unseres neuen Threads! Um den Thread zu starten müssen wir nur eine neue Instanz unserer Klasse erzeugen. Da wir keine neuen Felder in der erweiterten Klasse deklariert haben, müssen wir nicht einmal einen neuen Konstruktor programmieren. Es wird einfach der Konstruktor der Superklasse aufgerufen (in unserem Fall Thread() ). Die Methode start() ruft dann unsere überschriebene Methode run() auf, womit die Abarbeitung unseres Threads bereits beginnt:

meinThread  t = new meinThread();
 
t.start();      // ruft unsere run() Methode auf
 

Wollen wir unseren Thread beenden, dann schicken wir ihm einfach die stop() Meldung:

t.stop();       // Thread ist gestoppt und das System kann eventuelle
                // Hilfs- und Verwaltungsstrukturen abbauen
 

Soll ein Thread hingegen nur kurzfristig angehalten und danach wieder fortgesetzt werden, so wird dies wie folgt gemacht:

t.suspend();
...             // Eine Aktion, die ablaeuft, waehrend Thread t unterbrochen ist.
t.resume();
 

Implementieren des Runnable Interfaces

Sehr oft ist das Erweitern der Thread Klasse nicht erwünscht, weil dadurch Klassenhierarchien entstehen, die künstlich und konstruiert wirken. Wir machen uns nun die Fähigkeit von Java zunutze, Interfaces implementieren zu können.

Anstelle der Mehrfachvererbung - wie sie C++ kennt - bietet Java Interfaces an. Ein Interface ist eine reine Schnittstellenbeschreibung ohne jegliche Implementation. Anstatt von einer anderen Klasse zu erben (extends), kann eine neue Klasse ein Interface implementieren (implements). Das bedeutet, das diese Klasse eine Implementation zu sämtlichen Methoden liefern muss, die im Interface deklariert wurden.

Wir finden nun in der Klassenbibliothek folgendes Interface:

public interface java.lang.Runnable
{
    // Methods
    public abstract void run();
}
 

Unsere Klasse braucht jetzt nicht mehr eine Unterklasse von Thread zu sein, sondern kann in unserem objekt-orientieren Entwurf den Platz einnehmen, der vernünftig und/oder natürlich erscheint. Die einzige Bedingung die sie erfüllen muss ist, dass sie eine parameterlose Methode run() implementiert.

public class meineKlasse
    implements java.lang.Runnable
{
    public void run() {
      . . .  // hier steht der Code der als Thread abgearbeitet wird
    }
}

Die Implementation ist also praktisch dieselbe wie vorhin, jedoch der Aufruf ist einwenig aufwendiger. Zuerst wird ein Objekt der Klasse meineKlasse erzeugt. Danach wird ein Thread erzeugt, und zwar mit unserem Objekt als Parameter. Es wird dabei ein Thread generiert, der statt der eigenen, eine (im Argument-Objekt enthaltene) fremde run() Methode ausführt:

meineKlasse k = new meineKlasse();
Thread      t = new Thread(k);
 
t.start();

Wie bei einer Unterklasse, kann auch hier auf den Thread mit t.stop(), t.suspend() und t.resume() eingewirkt werden.

Parallelität - Threads in Java - Tips und Hinweise - Lösungsmöglichkeit
OOP - Werkzeuge - Referenzen - Fäden - Synchronisation - Applets - Dokumentation
Werkstatt - Bibliographie