Lassen Sie uns einige andere Unterschiede zwischen Thread und Runable anhand der folgenden Vergleichstabelle beobachten:
Vergleichstabelle
| Vergleichsgrundlage | Faden | Lauffähig |
|---|---|---|
| Basic | Jeder Thread erstellt ein eindeutiges Objekt und wird mit ihm verknüpft. | Mehrere Threads teilen sich die gleichen Objekte. |
| Erinnerung | Da jeder Thread ein eindeutiges Objekt erstellt, ist mehr Speicher erforderlich. | Da sich mehrere Threads das gleiche Objekt teilen, wird weniger Speicher verwendet. |
| Erweitern | In Java ist die Mehrfachvererbung nicht zulässig. Nachdem eine Klasse die Thread-Klasse erweitert hat, kann sie keine andere Klasse erweitern. | Wenn eine Klasse einen Thread definiert, der die Runnable-Schnittstelle implementiert, besteht die Möglichkeit, eine Klasse zu erweitern. |
| Benutzen | Ein Benutzer muss die Thread-Klasse nur erweitern, wenn er die anderen Methoden in der Thread-Klasse überschreiben möchte. | Wenn Sie nur die Run-Methode spezialisieren möchten, ist die Implementierung von Runnable die bessere Option. |
| Kupplung | Durch das Erweitern der Thread-Klasse wird eine enge Kopplung eingeführt, da die Klasse Code der Thread-Klasse und den dem Thread zugewiesenen Job enthält | Durch die Implementierung der Runnable-Schnittstelle wird die lose Kopplung eingeführt, da der Code von Thread von Threads getrennt ist. |
Definition der Gewindeklasse
Thread ist eine Klasse im Paket java.lang . Die Thread-Klasse erweitert eine Object- Klasse und implementiert ausführbare Schnittstellen. Die Thread-Klasse verfügt über Konstruktoren und Methoden zum Erstellen und Bearbeiten des Threads. Wenn Sie mehrere Threads erstellen, erstellt jeder Thread ein eindeutiges Objekt und wird mit diesem Objekt verknüpft. Wenn Sie eine Thread-Klasse erstellen, die die Thread-Klasse erweitert, können Sie keine weitere Klasse erweitern, da Java keine Mehrfachvererbung unterstützt. Daher sollten Sie die Thread-Klasse nur erweitern, wenn Sie auch andere Methoden der Thread-Klasse überschreiben möchten. Lassen Sie uns ein Beispiel zum Erstellen eines Threads sehen, der eine Thread-Klasse erweitert.
/ * Definieren eines Threads * / Class Mythread erweitert Thread {/ * - Job des Threads * / public void run () {for (int i = 0; i <10; i ++) {System.Out.Println ("Child Thread") ); }} Klasse mainThread {/ * Job des Hauptthreads * / public static void main (String args []) {Mythread mt = new Mythread (); / * main thread hat den untergeordneten Thread erstellt * / mt.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Ausgabe * / Hauptfaden Hauptfaden Hauptfaden Hauptfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Hauptfaden Unterfaden Hauptfaden Unterfaden Hauptfaden Unterfaden Unterfaden Unterfaden Hauptfaden Unterfaden Unterfaden Unterfaden Hauptfaden Im obigen Code erstelle ich eine Klasse Mythread, die die Thread-Klasse erweitert und eine Run-Methode der Thread-Klasse überschreibt. In der Klasse, die die Hauptmethode enthält, erstelle ich ein Thread-Objekt (mt) der Mythread-Klasse, und mit dem Thread-Objekt habe ich die start () -Methode aufgerufen. Die start-Methode startet die Ausführung des Threads und gleichzeitig ruft JVM die run-Methode des Threads auf. Jetzt gibt es zwei Threads im Programm, einen Haupt-Thread und einen zweiten, vom Haupt-Thread erstellten, untergeordneten Thread. Die Ausführung beider Threads findet gleichzeitig statt, aber die genaue Ausgabe kann nicht vorgetäuscht werden.
Definition der ausführbaren Schnittstelle
Runable ist eine Schnittstelle im Paket java.lang . Durch die Implementierung einer Runnable-Schnittstelle können wir einen Thread definieren. Runnable-Schnittstelle verfügt über eine einzige Methode run (), die von der Klasse implementiert wird, die die Runnable-Schnittstelle implementiert. Wenn Sie einen Thread definieren, der eine Runnable-Schnittstelle implementiert, können Sie noch andere Klassen erweitern. Wenn Sie mehrere Threads erstellen, indem Sie die ausführbare Schnittstelle implementieren, verwendet jeder Thread die gleiche ausführbare Instanz. Lassen Sie uns lernen, wie Sie einen Thread mithilfe der Runnable-Schnittstelle definieren.
/ * Definieren eines Threads * / Class Runnablethread implementiert Runnable {/ * - Job des Threads * / public void run () {für (int i = 0; i <10; i ++) {System.Out.Println ("untergeordneter Thread") ); }} Klasse mainThread {/ * Job des Hauptthreads * / public static void main (String args []) {Mythread rt = new Mythread (); / * main thread hat das ausführbare Objekt erstellt * / Thread t = new Thread (rt); / * main thread erstellt einen untergeordneten Thread und übergibt das ausführbare Objekt * / t.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Main Thread"); }}} / * Ausgabe * / Hauptfaden Hauptfaden Hauptfaden Hauptfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Unterfaden Hauptfaden Unterfaden Hauptfaden Unterfaden Hauptfaden Unterfaden Unterfaden Unterfaden Hauptfaden Unterfaden Unterfaden Unterfaden Hauptfaden Im obigen Code habe ich eine Klasse Runnablethread erstellt, die die Runnable-Schnittstelle implementiert und den Job des Threads definiert, indem die run () -Methode der Runnable-Schnittstelle implementiert wird. Dann erstelle ich eine Klasse mainthread, die die Hauptmethode enthält. Innerhalb der Hauptmethode habe ich ein ausführbares Objekt der Klasse Runnablethread deklariert und dieses Objekt beim Deklarieren eines Threads an den Konstruktor des Threads übergeben. Auf diese Weise verknüpfte ich das Threadobjekt (t) mit einem ausführbaren Objekt (rt). Dann ruft das Thread-Objekt die Startmethode des Threads auf, die die run-Methode der Runnablethread-Klasse weiter aufruft. Wenn ich ein ausführbares Objekt nicht mit einem Thread-Objekt verknüpft hätte, hätte die Thread-Startmethode die Run-Methode der Thread-Klasse aufgerufen. Nun gibt es wieder zwei Threads im Code: Haupt-Thread und Haupt-Thread erstellt untergeordneten Thread, die beide gleichzeitig ausgeführt werden, aber eine exakte Ausgabe kann niemals vorgetäuscht werden.
Hauptunterschiede zwischen Thread und Run in Java
- Jeder Thread, der durch Erweitern der Thread-Klasse erstellt wird, erstellt ein eindeutiges Objekt und wird mit diesem Objekt verknüpft. Andererseits hat jeder Thread, der durch Implementieren einer ausführbaren Schnittstelle erstellt wurde, dieselbe ausführbare Instanz.
- Da jeder Thread einem eindeutigen Objekt zugeordnet ist, wenn er durch Erweitern der Thread-Klasse erstellt wird, ist mehr Speicher erforderlich. Auf der anderen Seite hat jeder Thread, der durch Implementieren der ausführbaren Schnittstelle erstellt wurde, den gleichen Objektbereich und benötigt daher weniger Speicher.
- Wenn Sie die Thread-Klasse dann erweitern, können Sie jede andere Klasse erben, da Java keine Mehrfachvererbung zulässt. Die Implementierung von Runnable bietet jedoch die Möglichkeit, dass eine Klasse eine andere Klasse erbt.
- Eine Thread-Klasse muss nur erweitert werden, wenn sie andere Methoden der Thread-Klasse überschreiben oder spezialisieren muss. Sie müssen eine Runnable-Schnittstelle implementieren, wenn Sie nur die Run-Methode spezialisieren möchten.
- Durch das Erweitern der Thread-Klasse wird eine enge Kopplung im Code eingeführt, da der Code von Thread und der Job von Thread in derselben Klasse enthalten sind. Andererseits führt die implementierende ausführbare Schnittstelle eine lose Kopplung im Code ein, da der Code von Thread von dem dem Thread zugewiesenen Job getrennt wird.
Fazit:
Es wird bevorzugt, eine Runnable-Schnittstelle zu implementieren, anstatt die Thread-Klasse zu erweitern. Bei der Implementierung von Runnable wird Ihr Code lose gekoppelt, da sich der Code des Threads von der Klasse unterscheidet, die dem Thread den Job zuweisen. Es erfordert weniger Speicher und ermöglicht es einer Klasse, jede andere Klasse zu erben.
