Unterschied zwischen Thread-Klasse und ausführbarer Schnittstelle in Java

2019

Ein Thread kann auf zwei Arten definiert werden. Erstens, indem Sie eine Thread-Klasse erweitern, die bereits eine ausführbare Schnittstelle implementiert hat. Zweitens durch direkte Implementierung einer Runnable-Schnittstelle . Wenn Sie einen Thread definieren, indem Sie die Thread-Klasse erweitern, müssen Sie die run () -Methode in der Thread-Klasse überschreiben. Wenn Sie einen Thread definieren, der eine Runnable-Schnittstelle implementiert, müssen Sie die einzige run () - Methode der Runnable-Schnittstelle implementieren. Der grundlegende Unterschied zwischen Thread und Runnable besteht darin, dass jeder Thread, der durch Erweitern der Thread-Klasse definiert wird, ein eindeutiges Objekt erstellt und mit diesem Objekt verknüpft wird. Auf der anderen Seite hat jeder Thread, der durch die Implementierung der ausführbaren Schnittstelle definiert wurde, dasselbe Objekt.

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.