Java Creation Threads (Runnable -Schnittstelle und Thread -Klasse)
In den meisten Fällen wird ein Thread erstellt, indem ein Thread -Objekt instanziiert. Java definiert zwei Möglichkeiten:
Im Folgenden beschreibt jede Methode nacheinander.
Implementierung der Runnable -Schnittstelle
Der einfachste Weg, einen Thread zu erstellen, besteht darin, eine Klasse zu erstellen, die die runnable Schnittstelle implementiert. Runnable Abstracts eine Codeausführungseinheit. Sie können Threads für jedes Objekt erstellen, indem Sie die Runnable -Schnittstelle implementieren. Um die Runnable -Schnittstelle zu implementieren, muss eine Klasse nur eine einfache Methode von Run () implementieren, die wie folgt deklariert wird:
öffentliche void run ()
In Run () können Sie Code zum Erstellen neuer Threads definieren. Es ist wichtig, Folgendes zu verstehen: Die Run () -Methode kann andere Methoden aufrufen, andere Klassen beziehen und Variablen wie den Haupt -Thread deklarieren. Der einzige Unterschied besteht darin, dass Run () einen weiteren gleichzeitigen Eintrag zur Ausführung von Threads im Programm festlegt. Wenn run () zurückkehrt, endet der Thread.
Nachdem Sie eine Klasse erstellt haben, die die Runnable -Schnittstelle implementiert, müssen Sie ein Objekt der Thread -Klasse in der Klasse instanziieren. Die Thread -Klasse definiert mehrere Konstruktoren. Was wir verwenden werden, ist wie folgt:
Thread (Runnable Threadob, String ThreadName)
In diesem Konstruktor ist ThreadOB eine Instanz, die die Runnable -Schnittstellenklasse implementiert. Dies definiert den Ausgangspunkt für die Thread -Ausführung. Der Name des neuen Threads wird durch ThreadName definiert.
Nachdem ein neuer Thread erstellt wurde, wird erst ausgeführt, bis seine Start () -Methode aufgerufen wird, die in der Thread -Klasse definiert ist. Im Wesentlichen führt start () einen Anruf zum Run () aus. Die Start () -Methode wird wie folgt deklariert:
void start ()
Das folgende Beispiel besteht darin, einen neuen Thread zu erstellen und ihn auszuführen:
// einen zweiten Thread erstellen : " + t); t.start (); // Starten Sie den Thread} // Dies ist der Einstiegspunkt für den zweiten Thread. Public void run () {try {for (int i = 5; i> 0; i i i i> 0; i i i i> 0; i - -) {System.out.println ("Child Thread:" + i); out .println ("untergeordnetes Thread."); 0; ); Im NewThead -Konstruktor wird das neue Thread -Objekt durch die folgende Anweisung erstellt:
t = neuer Thread (this, "Demo -Thread");
Dies zeigt an, dass in diesem Objekt der neue Thread die Run () -Methode aufruft. Dann wird start () aufgerufen und die Ausführung des Threads wird mit der Run () -Methode gestartet. Dies führt dazu, dass der untergeordnete Thread die Ausführung beginnt. Nach dem Aufrufen von Start () kehrt der New Thread Constructor zu Main () zurück. Wenn der Hauptfaden wiederhergestellt ist, erreicht er die für die Schleife. Die beiden Threads laufen weiter und teilen die CPU, bis ihre Schleife endet. Die Ausgabe dieses Programms ist wie folgt:
Child Thread: Thread [Demo -Thread, 5, Haupt] Haupt Thread: 5Child -Thread: 5Child -Thread: 4Main -Thread: 4Child -Thread: 3Child -Thread: 2Main -Thread: 3Child -Thread: 1e Xiting Child Thread.Main -Thread: 2Main -Thread: 1Main -Thread begleitet .
Wie bereits erwähnt, muss in einem Multi-Thread-Programm der Haupt-Thread normalerweise der letzte Thread sein, der läuft. Tatsächlich kann für einige alte JVMs, wenn der Hauptfaden vor dem Kinderfaden endet, das Java -Laufzeitsystem "hängen". Das oben genannte Programm stellt sicher, dass der Hauptfaden am Ende endet, da der Hauptfaden für 1000 Millisekunden schläft, während der Kinderfaden nur 500 Millisekunden beträgt. Dies führt dazu, dass der Kinderfaden endet, bevor der Hauptfaden endet. Kurz gesagt, Sie werden einen besseren Weg sehen, um auf das Ende des Threads zu warten.
Erweiterter Faden
Eine andere Möglichkeit, einen Thread zu erstellen, besteht darin, eine neue Klasse zu erstellen, die die Thread -Klasse erweitert und dann eine Instanz dieser Klasse erstellt. Wenn eine Klasse Thread erbt, muss sie die Run () -Methode überlasten, die der Eintrag in den neuen Thread ist. Es muss auch die Start () -Methode aufrufen, um die neue Thread -Ausführung zu starten. Im Folgenden ist das vorherige Programm mit der erweiterten Thread -Klasse umzuschreiben:
// Erstellen Sie einen zweiten Thread, indem Sie ThreadClass -NewThread erweitern {newThread () {// einen neuen, zweiten Thread Super ("Demo -Thread"); (); // starten Sie den Thread} // Dies ist der Einstiegspunkt für den zweiten Thread. ("Child Thread:" + i); ");}} Klasse ExtendThread {public static void main (String args []) {new NewThead (); // Erstellen Sie einen neuen Thread-Versuch {für (int i = 5; i> 0; i--) {System. OUT ::::::::::::::::: .println ("Hauptfache:" + i); Haupt -Thread unterbrochen. ");} System.ou t.println (" Hauptfadenausgang ");}} Dieses Programm generiert die gleiche Ausgabe wie die vorherige Version. Der untergeordnete Thread wird durch das instanziierte NewThrad -Objekt erzeugt, das aus der Thread -Klasse abgeleitet ist. Beachten Sie den Anruf bei Super () in New Thread. Diese Methode ruft den Thread -Konstruktor des folgenden Formulars auf:
öffentlicher Thread (String -Threadname)
Hier gibt ThreadName den Threadnamen an.
Wählen Sie die richtige Methode
An diesem Punkt werden Sie sich definitiv fragen, warum Java zwei Möglichkeiten hat, Kinderfäden zu erstellen, die besser ist. Alle Fragen werden auf einen Punkt zurückgeführt. Die Thread -Klasse definiert eine Vielzahl von Methoden, die durch abgeleitete Klassen überladen werden können. Für alle Methoden ist das einzige, was überladen werden muss, die Run () -Methode. Dies ist natürlich die gleiche Methode, die zur Implementierung der Runnable -Schnittstelle erforderlich ist. Viele Java -Programmierer glauben, dass Klassen nur dann verlängert werden sollten, wenn sie gestärkt oder modifiziert werden. Wenn Sie also andere Thread -Methoden nicht überlasten, ist es am besten, nur die Runnable -Schnittstelle zu implementieren. Natürlich liegt es an Ihnen, sich zu entscheiden. In anderen Teilen dieses Kapitels wenden wir jedoch Klassen an, in denen die Runnable -Schnittstelle implementiert wird, um Threads zu erstellen.