21.2 Eine
eigene Thread-Klasse |
|
Um
Ausführungen eines Programms nebenläufig, also parallel zueinander
ausführen zu können, bringt man sie in Klassen unter die selbst einen
Thread darstellen. In Java ist dies leicht zu realisieren. Man lässt seine
Klasse von der fertigen Klasse Threads erben und überschreibt die von
Thread geerbten Methode run(). In dieser Methode bringt man die
Anweisungen unter, die später nebenläufig abgearbeitet werden sollen.
|
|
Download: EigenerThread. java |
|
In der
run()-Methode
implementieren wir eine Schleife, in der bei jedem Durchgang die
Klassenmethode sleep(int
millis) aufgerufen wird. Diese
Methode hat EigenerThread von Thread geerbt. Wird sie ausgeführt, so wird
der Thread, der die run()-Methode kontrolliert für eine gewisse Zeit
angehalten. Die 'Schlafdauer' wird der Methode in Millisekunden übergeben.
Beim Aufruf in unserer Schleife übergeben wir der Methode
sleep(...)
eine Zufallszahl. Beim Ausführen der Methode kann es zu einer Ausnahme
kommen, weshalb eine
try-catch
Konstruktion implementiert werden muss. Im
try-Block
implementieren wir die 'eigentliche' Funktionalität von
run().
Im Block der
catch(...)-Methode
bringen wir das unter, was getan werden soll, falls
sleep(...)
eine Ausnahme auslöst. Eine solche Ausnahme liefert ein Objekt des Typs
InterruptedException,
deshalb muss
catch ein Objekt vom Typ
InterruptedException übergeben werden können. Der Einfachheit halber, wird im Ausnahmefall nichts passieren.
|
|
Download: EigenerThread Demo.java |
Um die
eigene Threadklasse zu testen, benutzen wir ein Demoprogramm, in der zwei
Instanzen unserer selbstgeschriebenen Threadklasse benutzt.
|
Um einen
Thread zu starten, benutzt man die von
Thread
geerbte Methode start().
Diese Methode organisiert den Thread und ruft unter anderem die
run()-Methode
auf. |
|
Die Methode
getName()
liefert den Namen des Threads, den der Standardkonstruktor von Thread
selbst generiert hat. Bei der Instanziierung von EigenerThread wir der
Standardkonstruktor EigenerThread() aufgerufen, der seinerseits den
Standardkonstruktor von Thread aufruft. In der Klasse
EigenerThread
haben wir keinen Konstruktor implementiert, aber der Compiler fügt den
Standardkonstruktor automatisch hinzu. der seinerseits den
Standardkonstruktor der Vaterklasse also von
Thread
aufruft. Man hat die Möglichkeit 'seinem' Thread einen eigenen Namen zugeben. Dazu schriebt man für die Klasse
EigenerThread einen eigenen Konstruktor, der gezielt, denjenigen
Konstruktor von Thread aufruft, mit dem man dem Thread-Objket bei seiner
Instanziierung einen Namen geben kann. Entsprechend wird das Demoprogramm
abgeändert:
|
|
neuer Konstruktor von EigenerThread |
|
Modifikation im Demo |
|
Neue Ausgabe
Download:
(Vers. 2) |
Die
Ausgabe zeigt, dass nicht nur die Namen anders ausgegeben werden, sie
zeigt auch, dass das erneute Starten der Demo auch die Reihenfolge, in der
die Thread 'zu Wort' kommen unterschiedlich ist, dass es sich also
tatsächlich um nebenläufige Prozesse handelt.
|
Starten
wir den Windows-Task-Manager und danach unser EigenerThreadDemo, so zeigt
sich im unter der Rubrik Prozesse der Interpreter java.exe mit 10
Threads. Zwei davon sind die von uns programmierten, wir erkennen dies
daran, dass die Zahl der Threads auf 9 sinkt, wenn einer der
selbstprogrammierten Threads fertig ist, 'seine Schleife' also den Zähler
10 erreicht und ausgegeben hat. |
|
zur Startseite | www.pohlig.de (C) MPohlig 2003 |