Réponse.

Historique de la question :

Java prend en charge le multithreading depuis le départ. Les threads permettent d'exécuter plusieurs tâches en parallèle, en utilisant efficacement les processeurs multicœurs. La JVM fournit une couche d'abstraction au-dessus des threads du système d'exploitation.

Problème :

La création, la gestion et la terminaison des threads nécessitent une compréhension claire de leur cycle de vie, de la synchronisation et des états de concurrence possibles. Une utilisation imprudente des threads peut conduire à des deadlocks, à un accès incorrect aux ressources et à des journaux d'erreurs complexes.

Solution :

En Java, les threads peuvent être créés en étendant la classe Thread ou en implémentant l'interface Runnable, ainsi que par des moyens modernes tels que ExecutorService. Il est important de terminer correctement les threads, de gérer leur cycle de vie et de synchroniser l'accès aux données partagées.

Exemple de création et de terminaison d'un thread :

class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Le thread est en cours d'exécution");
    }
}

public class ThreadExample {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start(); // démarrer le thread
        try {
            t.join(); // attendre la fin
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Caractéristiques clés :

Les threads doivent être lancés avec la méthode start(), et non run() (sinon, il n'y aura pas de véritable parallélisme)
Pour une terminaison correcte, il est important d'utiliser join()
Un thread terminé ne peut pas être relancé : un nouvel appel de start lancera IllegalThreadStateException

Questions piégées.

Peut-on relancer un thread après sa terminaison ?

Non. Après avoir terminé, un thread est considéré comme "mort", et un nouvel appel à start() entraînera IllegalThreadStateException.

Quelle est la différence entre l'appel de t.run() et t.start()?

t.run() appellera simplement la méthode run dans le thread actuel, sans créer de nouveau thread d'exécution. Seul t.start() crée un thread distinct sur le système d'exploitation.

Que se passe-t-il si le thread se termine avec une exception non traitée ?

Si une exception non traitée est lancée, le thread se termine de manière inattendue, sa trace de pile sera affichée dans le flux d'erreurs, les autres threads ne seront pas affectés.

Erreurs typiques et anti-patterns

Appel de run() au lieu de start()
Terminaison inappropriée du thread (par exemple, absence de gestion d'InterruptedException)
Rendre le thread infini sans conditions de terminaison

Exemple de la vie réelle

Cas négatif

Un programmeur lance un thread avec la méthode run(), pensant qu'il fonctionne parallèlement à main, mais en réalité tout s'exécute de manière séquentielle.

Avantages :

La logique du programme fonctionne correctement

Inconvénients :

Pas de parallélisme, optimisation du temps d'exécution manquée

Cas positif

Utilisation correcte de start(), gestion appropriée des exceptions, utilisation de join() pour attendre la terminaison des threads.