“implements Runnable” vs “extends Thread” en Java

Oui: met en œuvre Runnable est la meilleure façon de le faire, de l'OMI. Vous n'êtes pas vraiment spécialisé le fil de comportement. Vous êtes juste de donner quelque chose à exécuter. Cela signifie que composition est le philosophiquement plus "purs" de chemin à parcourir.

Dans pratique termes, cela signifie que vous pouvez mettre en œuvre Runnable et de l'étendre à partir d'une autre catégorie.

Morale de l'histoire:

Hériter uniquement si vous souhaitez remplacer un comportement.

Ou plutôt il doit être lu comme suit:

Hériter à moins, interface plus.

Une chose que je suis surpris, n'a pas encore été mentionnés, c'est que la mise en œuvre de Runnable rend votre classe plus souple.

Si vous étendez le thread de l'action que vous faites est toujours dans un fil de discussion. Cependant, si vous mettez en œuvre Runnable il n'a pas à être. Vous pouvez l'exécuter dans un thread, ou de passer à une sorte d'exécuteur testamentaire de service, ou tout simplement passer autour d'une tâche au sein d'un seul thread de l'application (peut-être à être exécuté plus tard, mais dans le même thread). Les options sont beaucoup plus ouverts si vous venez d'utiliser Runnable que si vous vous lier à Thread.

En fait, Il n'est pas sage de comparer Runnable et Thread les uns avec les autres.

Ce deux ont une dépendance et parenté dans le multi-threading comme Wheel and Engine relation de véhicule à moteur.

Je dirais, il n'y a qu'une seule manière pour les multi-threading avec deux étapes. Permettez-moi de faire mon point.

Praticable:

Lors de la mise en œuvre de interface Runnable cela signifie que vous sont en train de créer quelque chose qui est run able dans un thread différent. Maintenant en train de créer quelque chose qui peut s'exécuter à l'intérieur d'un thread (runnable à l'intérieur d'un fil), ne signifie pas la création d'un Thread.

Si la classe MyRunnable n'est rien mais une classe ordinaire avec un void run méthode.
Et c'est les objets à quelques les objets ordinaires avec seulement une méthode run qui va s'exécuter normalement, lorsqu'on les appelle. (sauf si on fait passer l'objet dans un thread).

Fil:

class Thread, Je dirais Une classe très spéciale, avec la capacité de commencer un nouveau Thread qui permet réellement multi-threading par le biais de son start() méthode.

Pourquoi pas sage de comparer?

Parce que nous avons besoin d'eux pour le multi-threading.

Pour le Multi-threading nous avons besoin de deux choses:

• Quelque chose qui peut fonctionner à l'intérieur d'un Thread (Runnable).
• Quelque chose Qui peut commencer un nouveau Thread (Thread).

Donc, techniquement et théoriquement les deux d'entre eux est nécessaire pour démarrer un thread, on va exécuter et on va le faire fonctionner (Comme Wheel and Engine de véhicule à moteur).

C'est pourquoi vous ne pouvez pas démarrer un thread avec MyRunnable vous avez besoin de la passer à une instance de Thread.

Mais il est possible de créer et d'exécuter un seul thread à l'aide de class Thread parce que la Classe Thread implémente Runnable sorte que nous savons tous Thread est aussi un Runnable à l'intérieur.

Enfin Thread et Runnable sont complètent l'une l'autre pour le multithreading pas de concurrent ou d'un remplacement.

Je ne suis pas un expert, mais je pense que l'une des raisons pour mettre en œuvre Exécutable au lieu de prolonger le Fil: Java prend uniquement en charge de l'héritage simple, de sorte que vous ne pouvez étendre une classe.

Edit: Ce d'abord dit "mise en Œuvre d'une interface nécessite moins de ressources." ainsi, mais vous avez besoin de créer un nouveau Thread instance de toute façon, si c'était faux.

Avec la sortie de Java 8, il y a maintenant une troisième option.

Runnable est un interface fonctionnelle, ce qui signifie que les instances de celui-ci peut être créé avec les expressions lambda ou de la méthode de référence.

Votre exemple peut être remplacé par:

new Thread(() -> { /* Code here */ }).start()

ou si vous souhaitez utiliser un ExecutorService et une méthode de référence:

executor.execute(runner::run)

Ce ne sont pas seulement beaucoup plus courte que vos exemples, mais aussi venir avec de nombreux avantages énoncés dans d'autres réponses de l'aide Runnable sur Thread, tels que la responsabilité unique et à l'aide de la composition, parce que vous n'êtes pas spécialisée le fil de comportement. De cette façon permet également d'éviter la création d'une classe supplémentaire si vous avez besoin d'un Runnable comme vous le faites dans vos exemples.

Tout le monde ici semble penser que la mise en œuvre des Exécutables est le chemin à parcourir et je n'ai pas vraiment en désaccord avec eux, mais il ya aussi un cas pour l'extension de Fil à mon avis, en fait, vous avez sorte de démonstration dans votre code.

Si vous mettez en œuvre Exécutable, puis la classe qui implémente Runnable n'a aucun contrôle sur le nom du thread, c'est le code d'appel que l'on peut définir le nom du thread, comme suit:

new Thread(myRunnable,"WhateverNameiFeelLike");

mais si vous étendez le Fil puis vous arrivez à gérer à l'intérieur de la classe elle-même (comme dans votre exemple vous nom le thread 'ThreadB'). Dans ce cas, vous:

) Peut donner un nom utile à des fins de débogage

B) sont en train de forcer qui que ce nom sera utilisé pour toutes les instances de cette classe (sauf si vous ignorez le fait qu'il s'agit d'un fil et faire avec elle comme si c'est un Exécutable, mais nous parlons de la convention de ici en tout cas, de manière peut ignorer la possibilité que je ressens).

Vous pourriez même, par exemple, une trace de la pile de sa création et de l'utiliser comme le nom du thread. Cela peut sembler étrange, mais selon la façon dont votre code est structuré, il peut être très utile à des fins de débogage.

Cela peut sembler une petite chose, mais lorsque vous avez une application complexe avec beaucoup de discussions et tout d'un coup les choses ont interrompu "(soit pour des raisons de blocage ou peut être à cause d'une faille de sécurité dans un protocole de réseau qui serait un peu moins évident, sans fin ou d'autres raisons), puis l'obtention d'un vidage de pile de Java où tous les fils sont appelés "Thread-1','Thread-2',"Thread-3" n'est pas toujours très utile (cela dépend de la façon dont vos threads sont structurés et si vous pouvez utilement dire qui est qui par leur trace de la pile ne soit pas toujours possible si vous utilisez des groupes de plusieurs threads exécutent tous le même code).

Avoir dit que vous pouvez bien sûr aussi faire le ci-dessus de façon générique par la création d'une extension de la classe thread qui définit son nom à une trace de la pile de sa création, d'appel et ensuite l'utiliser avec votre Exécutable implémentations au lieu de la norme java de la classe Thread (voir ci-dessous) mais en plus de la trace de la pile, il pourrait être plus spécifique au contexte de l'information qui serait utile dans le nom du thread pour le débogage (une référence à l'une des nombreuses files d'attente ou les sockets, il pourrait de traitement par exemple, dans ce cas, vous préférerez peut-être étendre Fil spécialement pour ce cas, de sorte que vous pouvez avoir le compilateur force de vous (ou d'autres) à l'aide de vos bibliothèques) pour passer certaines informations (par exemple, la file d'attente/socket en question) pour une utilisation dans le nom).

Voici un exemple de générique fil avec la pile d'appel de trace comme son nom l':

public class DebuggableThread extends Thread {
    private static String getStackTrace(String name) {
        Throwable t= new Throwable("DebuggableThread-"+name);
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(os);
        t.printStackTrace(ps);
        return os.toString();
    }

    public DebuggableThread(String name) {
        super(getStackTrace(name));
    }

    public static void main(String[] args) throws Exception {
        System.out.println(new Thread());
        System.out.println(new DebuggableThread("MainTest"));
    }
}

et voici un échantillon de la sortie de comparer les deux noms:

Thread[Thread-1,5,main]
Thread[java.lang.Throwable: DebuggableThread-MainTest
    at DebuggableThread.getStackTrace(DebuggableThread.java:6)
    at DebuggableThread.<init>(DebuggableThread.java:14)
    at DebuggableThread.main(DebuggableThread.java:19)
,5,main]

Puisque c'est un sujet très populaire et les bonnes réponses sont répartis sur tout et traitées en profondeur, j'ai senti qu'il est justifiable de compiler les bonnes réponses de la part des autres dans une forme plus concise, de sorte que les nouveaux arrivants ont une vue d'ensemble facile initial:

1. Vous généralement d'étendre une classe pour ajouter ou modifier les fonctionnalités. Donc, si vous ne voulez pas à remplacer tout comportement de Thread, puis utiliser l'Exécutable.

2. Dans la même lumière, si vous n'avez pas besoin à hériter thread méthodes, vous pouvez le faire sans que généraux en utilisant l'Exécutable.

3. De l'héritage simple: Si vous étendez Fil, vous ne peut pas s'étendre à partir d'une autre classe, donc, si c'est ce que vous devez faire, vous devez utiliser l'Exécutable.

4. Il est bon de séparer le domaine de la logique de moyens techniques, en ce sens, il est préférable d'avoir un Exécutable tâche isoler votre tâche de votre coureur.

5. Vous pouvez exécuter le même Exécutable objet à plusieurs reprises, un objet Thread, cependant, ne peut être lancé qu'une seule fois. (Peut-être la raison, pourquoi les Exécuteurs faire accepter Runnables, mais pas de Fils.)

6. Si vous développez votre tâche Exécutable, vous avez toute souplesse comment l'utiliser maintenant et dans l'avenir. Vous pouvez exécuter simultanément par les Exécuteurs testamentaires, mais également par le Thread. Et vous pourriez aussi utiliser/appel de la non-simultanément dans le même thread, comme n'importe quel autre type d'objet.

7. Cela rend également plus facile à séparé à la tâche de la logique et de la simultanéité aspects votre tests unitaires.

8. Si vous êtes intéressé par cette question, vous pourriez aussi être intéressé par les différence entre Appelable et Praticable.

Cette question est abordée dans d'Oracle Définition et lancement d'un Thread tutoriel:

Laquelle de ces idiomes devriez-vous utiliser? Le premier idiome, qui emploie un
L'objet praticable, est plus général, parce que l'objet Praticable peut
sous-classe d'une classe autre que de Fil. La deuxième idiome est plus facile à utiliser
dans des applications simples, mais il est limité par le fait que votre tâche
la classe doit être un descendant de Fil. Cette leçon se concentre sur la première
l'approche, qui sépare l'Exécutable tâche de l'objet Thread
que l'exécution de la tâche. Non seulement cette approche est plus souple, mais
il est applicable à haut niveau de filetage Api de gestion des couverts
plus tard.

En d'autres termes, la mise en œuvre de Runnable va travailler dans les scénarios où votre classe étend une classe autre que Thread. Java ne supporte pas l'héritage multiple. Aussi, l'extension de Thread ne sera pas possible lors de l'utilisation de certains de haut niveau thread de gestion des Api. Le seul scénario où l'extension Thread est préférable dans une petite application qui ne sera pas sujet à des mises à jour à l'avenir. Il est presque toujours préférable de mettre en œuvre Runnable car il est plus souple que votre projet se développe. Un changement de conception de ne pas avoir un impact majeur que vous pouvez implémenter plusieurs interfaces en java, mais seulement d'étendre une classe.

L'explication la plus simple serait par la mise en œuvre de Runnable on peut attribuer le même objet à plusieurs threads et chaque Thread partage le même objet unis et le comportement.

Par exemple, supposons qu'il existe deux threads, thread1 met un entier dans un tableau et thread2 prend des entiers à partir de la matrice lorsque le tableau est rempli. Notez que pour thread2 de travail, il a besoin de connaître l'état de la matrice, qu'il thread1 a rempli ou non.

La mise en œuvre de Runnable vous permet de disposer de la flexibilité nécessaire pour partager l'objet alors que extends Thread vous fait pour créer de nouveaux objets pour chaque threads donc toute mise à jour qui est fait par thread1 est perdu à thread2.

C'est le S de SOLIDE: Seule la responsabilité.

Un fil incarne la de course contexte (comme dans le contexte d'exécution: la trame de pile, l'id de thread, etc.) de la d'exécution asynchrone d'un morceau de code. Que morceau de code, idéalement, devrait être la même mise en œuvre, si synchrone ou asynchrone.

Si vous le bundle ensemble en une seule application, vous donnez de l'objet résultant de deux sans rapport avec causes de changement:

1. de la manipulation du fil dans votre application (ie. l'interrogation et la modification du contexte d'exécution)
2. algorithme mis en œuvre par le morceau de code (l'exécutable partie)

Si la langue que vous utilisez prend en charge partielle des classes ou de l'héritage multiple, vous pouvez séparer chaque cause dans son propre super classe, mais ça revient au même que de composer les deux objets, car leurs ensembles de fonctionnalités ne se chevauchent pas. C'est pour la théorie.

Dans la pratique, d'une manière générale, un programme n'a pas besoin de transporter plus de complexité que nécessaire. Si vous avez un thread de travail sur une tâche spécifique, sans jamais changer cette tâche, il est probablement inutile de faire les tâches des classes séparées, et votre code est plus simple.

Dans le contexte de Java, depuis l'installation est déjà là, il est probablement plus facile de démarrer directement avec stand alone Runnable classes, et de transmettre leurs instances pour Thread (ou Executor) des cas. Une fois utilisé pour ce motif, il n'est pas plus difficile à utiliser (ou même de lire) que la simple exécutable thread cas.

si vous utilisez l'exécutable, vous pouvez économiser de l'espace pour s'étendre à d'aucune autre classe.

Oui,
Si vous appelez ThreadA appel , alors pas besoin d'appeler la méthode start et de la méthode run est l'appel après appel de la ThreadA classe seulement.
Mais Si l'utilisation du ThreadB appel doivent ensuite nécessaire le début de thread pour appeler la méthode run.
Si vous avez plus de l'aide, de me répondre.

Java ne supporte pas l'héritage multiple, donc si vous étend la classe Thread alors aucune autre classe sera étendu.

Par Exemple: Si vous créez une applet, puis il doit s'étend classe Applet donc, ici, la seule façon de créer de thread est en implémentant l'interface Runnable

Différence entre le Fil et praticable
.Si nous sommes la création de Thread à l'aide de Fil de classe Nombre de thread égal au nombre d'objet que nous avons créé .
Si nous sommes la création de thread par l'implémentation de l'interface runnable alors nous pouvons utiliser un seul objet à la création de plusieurs threads.Si un seul objet est partagé par plusieurs Threads.Donc il va prendre moins de mémoire

Alors, selon le besoin, si nos données ne sont pas sensibles. De sorte qu'Il peut être partagé entre plusieurs Threads nous pouvons nous servir de l'interface Runnable.

Une différence entre la mise en œuvre Praticable et l'extension de discussion est que par l'extension de Fil, chacun de votre fils a un unique objet associé, tandis que la mise en œuvre des Exécutables, de nombreux threads peuvent partager la même instance d'objet.

Une classe qui implémente Runnable n'est pas d'un fil, juste une classe. Pour un Exécutable à être exécuté par un Thread, vous devez créer une instance de Thread et de passer l'Exécutable de l'instance en tant que cible.

Dans la plupart des cas, l'interface Runnable doit être utilisé si vous êtes planification pour remplacer la méthode run() et aucun autre Thread méthodes. Ceci est important parce que les classes ne doivent pas être sous-classé, à moins que le programmeur a l'intention de modifier ou d'améliorer le comportement fondamental de la classe.

Lorsqu'il est nécessaire d'étendre une super-classe, l'implémentation de l'interface Runnable est plus appropriée que l'utilisation de la classe Thread. Parce que nous pouvons étendre une autre classe lors de la mise en œuvre de l'interface Runnable de faire un thread. Mais si nous venons d'étendre la classe Thread on ne peut pas hériter d'une autre classe.

Thread est titulaire d'un comportement qui n'est pas destiné à être consulté;

• il est synchronisé verrou est utilisé pour joindre etc.
• il a des méthodes que vous pouvez accéder par accident.

toutefois, si vous sous-classe de Thread envisager plus de Fil est mis en œuvre.

public class ThreadMain {
    public int getId() {
        return 12345678;
    }

    public String getName() {
        return "Hello World";
    }

    public String getState() {
        return "testing";
    }

    public void example() {
        new Thread() {
            @Override
            public void run() {
                System.out.println("id: "+getId()+", name: "+getName()+", state: "+getState());
            }
        }.start();
    }

    public static void main(String[] args) {
        new ThreadMain().example();
    }
}

Si vous exécutez ce que vous pourrait s'attendre à ce

id: 12345678, name: Hello World, state: testing

cependant, vous n'êtes pas en appelant la méthode que vous pensez que vous êtes parce que vous êtes à l'aide de la méthode dans Thread pas ThreadMain et au lieu de cela, vous voyez quelque chose comme

id: 11, name: Thread-0, state: RUNNABLE

Dans les rares cas où vous ne l'exécuter une fois, vous devez étendre Fil en raison de la SEC. Si vous appelez plusieurs fois, vous devez mettre en œuvre Praticable parce que le même fil ne doit pas être redémarré.

1. L'extension de la thread de l'interface, est que vous faites de votre classe à se comporter comme un fil. Votre nouvelle classe sera comme une meilleure thread.

jshell> public class Test extends Thread{
   ...> public Test(String name){
   ...> super(name);
   ...> }
   ...> public void run(){
   ...> System.out.println(Thread.currentThread().getName());
   ...> }
   ...> }
|  created class Test

jshell> Test t1=new Test("MyThread");
t1 ==> Thread[MyThread,5,main]

Il crée un thread, pas la Test objet. Il va agir comme un seul thread. Vous ne pouvez pas partager l'instance de Test de classe entre les threads.

2. L'implémentation de l'interface runnable.

jshell> public class Test1 implements Runnable{
   ...> public void run(){
   ...> System.out.println(Thread.currentThread().getName());
   ...> }
   ...> public String getName(){
   ...> return "testing";}
   ...> }
|  created class Test1

jshell> Test1 t1=new Test1();
t1 ==> Test1@396a51ab  --> this creates Test1 object.

Cet objet peuvent être partagées entre les threads par,

jshell> Thread t1=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]

jshell> Thread t=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]

Je pense qu'il y a déjà beaucoup qui a été discuté sur ce sujet, pensé que cela pourrait être utile autour de la base.

Classe Thread définit plusieurs méthodes qui peuvent être overriden par l'extension de la classe. Mais pour créer un thread, nous devons remplacer la run() méthode. Même s'applique à Runnable ainsi.

Cependant Runnable est une méthode préférée de création d'un thread. Les principales raisons sont:

1. Depuis Exécutable est une interface, vous pouvez l'étendre à d'autres classes. Mais si vous étendez Thread alors que l'option a disparu.

2. Si vous n'êtes pas la modification ou l'amélioration de tout un tas de Thread fonctionnalités et l'extension de la Thread classe n'est pas un moyen privilégié.

La principale différence entre le Fil et l'Exécutable est:
- Fil est comme: Travailleur (exécuter Exécutables)
- Exécutable est comme: Travail (pour être exécuté par le Thread)