Extends Thread ou implements Runnable : comment ne pas échouer à l'entretien

implements Runnable vs extends Thread : pourquoi 90% des développeurs Java se trompent-ils ?

Imaginez : vous êtes en entretien dans une grande entreprise IT. Le recruteur sourit et pose une question "simple" : "Quelle est la différence entre implements Runnable et extends Thread en Java ?". Cela semble simple, non ? Mais c'est précisément là que, selon les données de Stack Overflow, même les développeurs expérimentés trébuchent. Des milliers de vues, des centaines de commentaires — le sujet "Java Runnable vs Thread" reste l'un des plus brûlants.

Dans cet article, nous ne nous contenterons pas d'énumérer les différences. Nous analyserons le top 5 des erreurs réelles que commettent les programmeurs et montrerons comment écrire un code multithread propre et évolutif. Si vous codez en Java et utilisez Thread directement — lisez attentivement. Peut-être créez-vous des problèmes sans même vous en rendre compte.

Petit rappel : qu'est-ce que Thread et Runnable ?

Avant de plonger dans les détails, rafraîchissons les bases. Java Thread est une classe représentant un fil d'exécution. Elle peut exécuter du code en mode parallèle. Runnable est une interface fonctionnelle avec une seule méthode run(). Elle décrit une tâche à exécuter, mais ne sait pas comment la lancer.

Voici un exemple classique avec extends Thread :

public class MyThread extends Thread {\n    @Override\n    public void run() {\n        System.out.println("Le thread fonctionne : " + Thread.currentThread().getName());\n    }\n\n    public static void main(String[] args) {\n        MyThread t = new MyThread();\n        t.start(); // Lancement d'un nouveau thread\n    }\n}

Et voici la même fonctionnalité avec implements Runnable :

public class MyTask implements Runnable {\n    @Override\n    public void run() {\n        System.out.println("La tâche s'exécute : " + Thread.currentThread().getName());\n    }\n\n    public static void main(String[] args) {\n        Thread t = new Thread(new MyTask());\n        t.start();\n    }\n}

À première vue, la différence est minime. Mais le diable, comme toujours, se cache dans les détails.

Top 5 des erreurs avec Thread et Runnable

Erreur n°1 : Hériter de Thread là où Runnable est nécessaire

Le problème le plus fréquent — un couplage fort avec la classe Thread. Lorsque vous écrivez extends Thread, votre classe devient un thread. Vous perdez la possibilité d'hériter d'une autre classe. Java est un langage à héritage unique, et c'est une limitation sérieuse.

Exemple de mauvais code :

public class DataProcessor extends Thread {\n    // Impossible d'étendre JFrame, ArrayList ou une autre classe utile\n    @Override\n    public void run() {\n        // traitement des données\n    }\n}

Comment faire : Utilisez implements Runnable. C'est une interface — vous pouvez l'implémenter dans n'importe quelle classe qui hérite déjà d'autre chose.

public class DataProcessor extends BaseService implements Runnable {\n    @Override\n    public void run() {\n        // traitement des données\n    }\n}

Erreur n°2 : Confusion entre run() et start()

Un classique. Les débutants (et pas seulement) appellent souvent run() au lieu de start(). La différence est cruciale : start() crée un nouveau thread et appelle run() à l'intérieur. run() s'exécute dans le thread actuel, comme une méthode normale.

Exemple d'erreur :

Thread t = new Thread(new MyTask());\nt.run(); // Ça fonctionne, mais dans le même thread ! Pas de multithreading.

La sortie console se fera dans le thread principal main, pas dans un nouveau. L'erreur est difficile à détecter car le code ne plante pas — il ne fait simplement pas ce que vous attendez.

Comment l'éviter : Utilisez toujours start() pour lancer un nouveau thread. En cas de doute, vérifiez