Observons d’autres différences entre Thread et Runnable à l’aide du tableau de comparaison ci-dessous:
Tableau de comparaison
| Base de comparaison | Fil | Runnable |
|---|---|---|
| De base | Chaque thread crée un objet unique et y est associé. | Plusieurs threads partagent les mêmes objets. |
| Mémoire | Comme chaque thread crée un objet unique, plus de mémoire est requise. | Comme plusieurs threads partagent le même objet, moins de mémoire est utilisée. |
| Extension | En Java, l'héritage multiple n'est pas autorisé. Par conséquent, après qu'une classe ait étendu la classe Thread, elle ne peut pas étendre une autre classe. | Si une classe définit un thread implémentant l'interface Runnable, elle a la possibilité d'étendre une classe. |
| Utilisation | Un utilisateur doit étendre la classe de thread uniquement s'il souhaite redéfinir les autres méthodes de la classe Thread. | Si vous souhaitez uniquement spécialiser la méthode d'exécution, l'implémentation de Runnable est une meilleure option. |
| Couplage | La classe de fils extensible introduit le couplage étroit car la classe contient le code de la classe de fils et le travail assigné au fil | L'implémentation de l'interface Runnable introduit un couplage lâche car le code de Thread est distinct du travail de Threads. |
Définition de classe de thread
Le fil est une classe du paquet java.lang . La classe Thread étend une classe Object et implémente des interfaces Runnable . La classe Thread a des constructeurs et des méthodes pour créer et opérer sur le thread. Lorsque nous créons plusieurs threads, chaque thread crée un objet unique et est associé à cet objet. Si vous créez une classe d'extension Thread, vous ne pouvez pas non plus étendre une autre classe, car Java ne prend pas en charge l'héritage multiple. Vous devez donc choisir d'étendre la classe Thread uniquement lorsque vous souhaitez également remplacer d'autres méthodes de la classe Thread. Voyons un exemple de création d'un thread étendant une classe Thread.
/ * Définition d'un thread * / Classe Mythread étend le travail du thread {/ * du thread * / public void run () {pour (int i = 0; i <10; i ++) {System.Out.Println ("Thread enfant" ) }} Classe mainThread {/ * travail du thread principal * / public static void main (String args []) {Mythread mt = new Mythread (); / * Le thread principal a créé le thread enfant * / mt.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Filetage principal"); }}} / * Sortie * / Fil principal Fil principal Fil principal Fil principal Fil d'enfant Fil d'enfant Fil d'enfant Fil d'enfant Fil principal Fil d'enfant Fil principal Fil d'enfant Fil principal Fil d'enfant Fil principal Fil principal Fil principal Fil d'enfant Fil d'enfant Fil d'enfant Dans le code ci-dessus, je crée une classe Mythread qui étend la classe Thread et remplace une méthode d'exécution de la classe Thread. Dans la classe contenant la méthode principale, je crée un objet thread (mt) de la classe Mythread. À l'aide de l'objet thread, j'ai appelé la méthode start (). La méthode start lance l'exécution du thread et, en même temps, JVM appelle la méthode d'exécution du thread. Il existe maintenant deux threads dans le programme, un thread principal et un second thread enfant créé par le thread principal. L'exécution des deux threads se produit simultanément, mais la sortie exacte ne peut pas être prétendue.
Définition de l'interface exécutable
Runnable est une interface dans le package java.lang . En implémentant l'interface Runnable, nous pouvons définir un thread. L'interface Runnable a une seule méthode run (), qui est implémentée par la classe qui implémente l'interface Runnable. Lorsque vous choisissez de définir un thread implémentant une interface Runnable, vous avez toujours le choix d’étendre toute autre classe. Lorsque vous créez plusieurs threads en implémentant l'interface Runnable, chaque thread partage la même instance exécutable. laissez-nous apprendre à définir un thread en utilisant l'interface Runnable.
/ * Définir un thread * / Class Runnablethread implémente Runnable {/ * travail du thread * / public void run () {pour (int i = 0; i <10; i ++) {System.Out.Println ("Thread enfant" ) }} Classe mainThread {/ * travail du thread principal * / public static void main (String args []) {Mythread rt = new Mythread (); / * Le thread principal a créé l'objet exécutable * / Thread t = new Thread (rt); / * thread principal crée un thread enfant et passe l'objet exécutable * / t.start (); for (int i = 0; i <10; i ++) {System.Out.Print ("Filetage principal"); }}} / * Sortie * / Fil principal Fil principal Fil principal Fil principal Fil d'enfant Fil d'enfant Fil d'enfant Fil d'enfant Fil principal Fil d'enfant Fil principal Fil d'enfant Fil principal Fil d'enfant Fil principal Fil principal Fil principal Fil d'enfant Fil d'enfant Fil d'enfant Dans le code ci-dessus, j'ai créé une classe Runnablethread qui implémente l'interface Runnable et définit le travail du thread en implémentant la méthode run () de l'interface Runnable. Ensuite, je crée une classe mainthread contenant la méthode main. Dans la méthode principale, j'ai déclaré un objet exécutable de la classe Runnablethread et passé cet objet au constructeur du Thread lors de la déclaration d'un thread. De cette façon, j'ai lié l'objet thread (t) à un objet exécutable (rt). Ensuite, l'objet thread appelle la méthode de démarrage du thread qui appelle ensuite la méthode d'exécution de la classe Runnablethread. Si je n'avais pas lié d'objet exécutable à un objet Thread, la méthode de démarrage threads aurait invoqué la méthode d'exécution de la classe Thread. Maintenant, encore une fois, il y a deux threads dans le code, le thread principal et le thread principal crée un thread enfant qui est exécuté simultanément mais la sortie exacte ne peut jamais être prétendue.
Différences clés entre thread et runnable en Java
- Chaque thread créé en étendant la classe Thread crée un objet unique pour lui et est associé à cet objet. D'autre part, chaque thread créé en implémentant une interface Runnable partage la même instance exécutable.
- Comme chaque thread est associé à un objet unique lorsqu’il est créé en étendant la classe Thread, il faut plus de mémoire. D'autre part, chaque thread créé en implémentant l'interface Runnable partage le même espace objet et nécessite donc moins de mémoire.
- Si vous étendez ensuite la classe Thread, vous pouvez hériter de toute autre classe, car Java n'autorise pas l'héritage multiple, alors que l'implémentation de Runnable permet toujours à une classe d'hériter de toute autre classe.
- Il faut étendre une classe Thread uniquement si elle doit remplacer ou spécialiser d'autres méthodes de la classe Thread. Vous devez implémenter une interface Runnable si vous souhaitez uniquement spécialiser la méthode d'exécution.
- L'extension de la classe Thread introduit un couplage étroit dans le code car le code de Thread et le travail de thread sont contenus dans la même classe. D'autre part, l'interface d'implémentation de Runnable introduit un couplage faible dans le code car le code de thread est distinct du travail attribué au thread.
Conclusion:
Il est préférable d'implémenter une interface Runnable plutôt que d'étendre la classe Thread. En implémentant Runnable, votre code est faiblement couplé car le code du thread est différent de celui de la classe qui attribue le travail au thread. Cela nécessite moins de mémoire et permet également à une classe d'hériter d'une autre classe.
