"implementiert Runnable" vs. "erweitert Thread" in Java

Question

Nach der Zeit, die ich mit Threads in Java Ich habe diese beiden Möglichkeiten gefunden, Themen zu schreiben:

Mit implementiert Runnable :

public class MyRunnable implements Runnable {
    public void run() {
        //Code
    }
}
//Started with a "new Thread(new MyRunnable()).start()" call

Oder, mit erweitert Thread :

public class MyThread extends Thread {
    public MyThread() {
        super("MyThread");
    }
    public void run() {
        //Code
    }
}
//Started with a "new MyThread().start()" call

Gibt es einen signifikanten Unterschied zwischen diesen beiden Codeblöcken?

Answer 1

Ja: Arbeitsgeräte Runnable ist IMO die beste Methode. Sie spezialisieren das Verhalten des Threads nicht wirklich. Du gibst ihm nur etwas zum Laufen. Das bedeutet Zusammensetzung ist die philosophisch "reineren" Weg zu gehen.

で praktisch bedeutet dies, dass Sie folgende Maßnahmen durchführen können Runnable und auch von einer anderen Klasse erweitern... und Sie können auch implementieren Runnable über einen Lambda-Ausdruck ab Java 8.

Answer 2

tl;dr: implementiert Runnable ist besser. Allerdings ist der Vorbehalt wichtig .

Im Allgemeinen würde ich empfehlen, etwas zu verwenden wie Runnable statt Thread weil es Ihnen erlaubt, Ihre Arbeit nur lose mit der von Ihnen gewählten Gleichzeitigkeit zu verbinden. Wenn Sie zum Beispiel eine Runnable und später zu entscheiden, dass dies in der Tat nicht eine eigene Thread können Sie einfach threadA.run() aufrufen.

Vorbehalt: Hier in der Gegend rate ich dringend von der Verwendung von rohen Fäden ab. Ich bevorzuge die Verwendung von Callables y FutureTasks (Aus der Javadoc: "A cancellable asynchronous computation"). Die Integration von Timeouts, das korrekte Abbrechen und das Thread-Pooling der modernen Gleichzeitigkeitsunterstützung sind für mich alle viel nützlicher als ein Haufen roher Threads.

Nachbereitung: Es gibt eine FutureTask Konstrukteur die es Ihnen ermöglicht, Runnables zu verwenden (wenn Sie sich damit am wohlsten fühlen) und dennoch die Vorteile der modernen Gleichzeitigkeitswerkzeuge zu nutzen. Um die Javadoc zu zitieren :

Wenn Sie kein bestimmtes Ergebnis benötigen, können Sie Konstruktionen dieser Art verwenden:

Future<?> f = new FutureTask<Object>(runnable, null)

Wenn wir also ihre runnable mit Ihrem threadA erhalten wir Folgendes:

new FutureTask<Object>(threadA, null)

Eine weitere Möglichkeit, näher an Runnables zu bleiben, ist ein ThreadPoolExecutor . Sie können die ausführen. Methode, um ein Runnable zu übergeben, das "die angegebene Aufgabe irgendwann in der Zukunft" ausführt.

Wenn Sie versuchen möchten, einen Thread-Pool zu verwenden, würde das obige Codefragment etwa wie folgt aussehen (unter Verwendung der Executors.newCachedThreadPool() Fabrikmethode):

ExecutorService es = Executors.newCachedThreadPool();
es.execute(new ThreadA());

Answer 3

Die Moral von der Geschicht':

Vererben Sie nur, wenn Sie ein bestimmtes Verhalten außer Kraft setzen wollen.

Oder besser gesagt: Es sollte heißen:

Weniger vererben, mehr verknüpfen.

Answer 4

Nun, so viele gute Antworten, ich möchte noch mehr dazu sagen. Dies wird helfen zu verstehen Extending v/s Implementing Thread .
Extends bindet zwei Klassendateien sehr eng aneinander und kann zu ziemlich schwer zu handhabendem Code führen.

Beide Ansätze erfüllen die gleiche Aufgabe, aber es gibt einige Unterschiede.
Der häufigste Unterschied ist

1. Wenn Sie die Klasse Thread erweitern, können Sie danach keine andere Klasse mehr erweitern, die Sie benötigen. (Wie Sie wissen, ist es in Java nicht möglich, mehr als eine Klasse zu erben).
2. Wenn Sie Runnable implementieren, können Sie Platz für Ihre Klasse sparen, um jede andere Klasse in der Zukunft oder jetzt zu erweitern.

Allerdings ist eine erheblicher Unterschied zwischen der Implementierung von Runnable und der Erweiterung von Thread ist, dass
by extending Thread, each of your threads has a unique object associated with it, whereas implementing Runnable, many threads can share the same object instance.

Das folgende Beispiel wird Ihnen helfen, die Situation besser zu verstehen

//Implement Runnable Interface...
class ImplementsRunnable implements Runnable {

    private int counter = 0;

    public void run() {
        counter++;
        System.out.println("ImplementsRunnable : Counter : " + counter);
    }
}

//Extend Thread class...
class ExtendsThread extends Thread {

    private int counter = 0;

    public void run() {
        counter++;
        System.out.println("ExtendsThread : Counter : " + counter);
    }
}

//Use the above classes here in main to understand the differences more clearly...
public class ThreadVsRunnable {

    public static void main(String args[]) throws Exception {
        // Multiple threads share the same object.
        ImplementsRunnable rc = new ImplementsRunnable();
        Thread t1 = new Thread(rc);
        t1.start();
        Thread.sleep(1000); // Waiting for 1 second before starting next thread
        Thread t2 = new Thread(rc);
        t2.start();
        Thread.sleep(1000); // Waiting for 1 second before starting next thread
        Thread t3 = new Thread(rc);
        t3.start();

        // Creating new instance for every thread access.
        ExtendsThread tc1 = new ExtendsThread();
        tc1.start();
        Thread.sleep(1000); // Waiting for 1 second before starting next thread
        ExtendsThread tc2 = new ExtendsThread();
        tc2.start();
        Thread.sleep(1000); // Waiting for 1 second before starting next thread
        ExtendsThread tc3 = new ExtendsThread();
        tc3.start();
    }
}

Ausgabe des obigen Programms.

ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1

Beim Ansatz der Runnable-Schnittstelle wird nur eine Instanz einer Klasse erstellt, die von verschiedenen Threads gemeinsam genutzt wird. Daher wird der Wert des Zählers für jeden einzelnen Thread-Zugriff erhöht.

Beim Thread-Klassen-Ansatz hingegen müssen Sie für jeden Thread-Zugriff eine eigene Instanz erstellen. Daher wird für jede Klasseninstanz ein anderer Speicher zugewiesen und jeder hat einen separaten Zähler, dessen Wert gleich bleibt, was bedeutet, dass kein Inkrement erfolgt, da keine der Objektreferenzen gleich ist.

Wann sollte man Runnable verwenden?
Verwenden Sie die Schnittstelle Runnable, wenn Sie von einer Gruppe von Threads aus auf dieselben Ressourcen zugreifen wollen. Vermeiden Sie hier die Verwendung der Thread-Klasse, da die Erstellung mehrerer Objekte mehr Speicher verbraucht und zu einem großen Leistungs-Overhead führt.

Eine Klasse, die Runnable implementiert, ist kein Thread und nur eine Klasse. Damit ein Runnable zu einem Thread wird, müssen Sie eine Instanz von Thread erstellen und sich selbst als Ziel übergeben.

In den meisten Fällen sollte die Runnable-Schnittstelle verwendet werden, wenn Sie nur planen, die run() Methode und keine anderen Thread-Methoden. Dies ist wichtig, weil Klassen nicht unterklassifiziert werden sollten, es sei denn, der Programmierer beabsichtigt, das grundlegende Verhalten der Klasse zu ändern oder zu verbessern.

Wenn es notwendig ist, eine Oberklasse zu erweitern, ist die Implementierung der Runnable-Schnittstelle besser geeignet als die Verwendung der Thread-Klasse. Denn wir können eine andere Klasse erweitern und gleichzeitig die Runnable-Schnittstelle implementieren, um einen Thread zu erstellen.

Ich hoffe, das wird helfen!

Answer 5

Wenn Sie irgendeine andere Klasse implementieren oder erweitern wollen, dann Runnable Schnittstelle ist am besten geeignet, andernfalls, wenn Sie keine andere Klasse erweitern oder implementieren wollen, dann Thread Klasse ist vorzuziehen.

Der häufigste Unterschied ist

Wenn Sie extends Thread Klasse, danach können Sie keine andere Klasse mehr erweitern, die Sie benötigen. (Wie Sie wissen, ist es in Java nicht möglich, mehr als eine Klasse zu erben).

Wenn Sie implements Runnable können Sie Platz für Ihre Klasse sparen, um eine andere Klasse in der Zukunft oder jetzt zu erweitern.

• Java unterstützt keine Mehrfachvererbung, d.h. Sie können nur eine Klasse in Java erweitern. Sobald Sie also die Klasse Thread erweitert haben, haben Sie Ihre Chance verloren und können keine andere Klasse in Java erweitern oder erben.

• In der objektorientierten Programmierung bedeutet die Erweiterung einer Klasse im Allgemeinen das Hinzufügen neuer Funktionen und das Ändern oder Verbessern von Verhaltensweisen. Wenn wir keine Änderungen am Thread vornehmen, verwenden wir stattdessen die Schnittstelle Runnable.

• Die Schnittstelle Runnable stellt einen Task dar, der entweder von einem einfachen Thread oder Executors oder auf andere Weise ausgeführt werden kann. Daher ist die logische Trennung von Task als Runnable und nicht als Thread eine gute Designentscheidung.

• Trennen von Aufgabe als Runnable bedeutet, wir können die Aufgabe wiederverwenden und hat auch die Freiheit, es von verschiedenen Mitteln auszuführen. da Sie einen Thread nicht neu starten können, sobald es abgeschlossen ist. wieder Runnable vs Thread für Aufgabe, Runnable ist Gewinner.

• Der Java-Designer hat dies erkannt und deshalb akzeptieren Executors Runnable als Task und haben einen Worker-Thread, der diese Tasks ausführt.

• Das Vererben aller Thread-Methoden ist zusätzlicher Overhead, nur um einen Task zu repräsentieren, was mit Runnable leicht möglich ist.

Mit freundlicher Genehmigung von javarevisited.blogspot.com

Dies waren einige der bemerkenswerten Unterschiede zwischen Thread und Runnable in Java. Wenn Sie weitere Unterschiede zwischen Thread und Runnable kennen, teilen Sie sie bitte in den Kommentaren mit. Ich persönlich bevorzuge Runnable gegenüber Thread für dieses Szenario und empfehle die Verwendung der Runnable- oder Callable-Schnittstelle je nach Ihren Anforderungen.

Der wesentliche Unterschied besteht jedoch darin.

Wenn Sie extends Thread Klasse erstellt jeder Ihrer Threads ein eindeutiges Objekt und assoziiert es mit diesem. Wenn Sie implements Runnable wird dasselbe Objekt für mehrere Threads freigegeben.