Les threads permettent d'exécuter plusieurs tâches simultanément dans un programme Java. Cette capacité de programmation concurrente est essentielle pour créer des applications performantes et réactives. Ce chapitre vous introduit aux concepts fondamentaux des threads, à leur création, à leur gestion, et aux problèmes de synchronisation qui peuvent survenir.

12.1Introduction aux threads

12.1.1 – Qu'est-ce qu'un thread ?

Un thread (fil d'exécution) est une unité d'exécution indépendante dans un programme Java. Un programme peut avoir plusieurs threads qui s'exécutent simultanément, permettant ainsi d'effectuer plusieurs tâches en parallèle.

🔍 Concept fondamental

Par défaut, un programme Java s'exécute dans un seul thread (le thread principal ou "main thread"). Cependant, vous pouvez créer plusieurs threads pour exécuter différentes parties de votre code simultanément.

Analogie :

Programme séquentiel : Comme un cuisinier qui fait une tâche à la fois (préparer les légumes, puis cuire, puis servir)
Programme multi-thread : Comme plusieurs cuisiniers travaillant en parallèle (un prépare les légumes pendant qu'un autre cuit la viande)

💻 Exemple : Programme séquentiel vs Multi-thread

Programme séquentiel (un seul thread)

public class ProgrammeSequentiel {
    public static void main(String[] args) {
        // Tâche 1
        for (int i = 1; i <= 5; i++) {
            System.out.println("Tâche 1 : " + i);
            try {
                Thread.sleep(1000);  // Pause de 1 seconde
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        // Tâche 2 (attend que la tâche 1 soit terminée)
        for (int i = 1; i <= 5; i++) {
            System.out.println("Tâche 2 : " + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
// Résultat : Tâche 1 complète, puis Tâche 2 complète (séquentiel)

Programme multi-thread

public class ProgrammeMultiThread {
    public static void main(String[] args) {
        // Créer et démarrer le thread 1
        Thread thread1 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Tâche 1 : " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        // Créer et démarrer le thread 2
        Thread thread2 = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println("Tâche 2 : " + i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        
        thread1.start();  // Démarrer le thread 1
        thread2.start();  // Démarrer le thread 2
        
        // Les deux threads s'exécutent en parallèle
    }
}
// Résultat : Les tâches 1 et 2 s'exécutent simultanément (mélangées)

Différence clé :

Séquentiel : Les tâches s'exécutent une après l'autre (total : ~10 secondes)
Multi-thread : Les tâches s'exécutent en parallèle (total : ~5 secondes)
Dans le programme multi-thread, les messages des deux threads peuvent être mélangés car ils s'exécutent simultanément

🎯 Avantages des threads

Performance : Utilisation efficace des processeurs multi-cœurs
Réactivité : Interface utilisateur qui reste réactive pendant les opérations longues
Parallélisme : Traitement simultané de plusieurs tâches
Efficacité : Meilleure utilisation des ressources système

⚠️ Défis des threads

Synchronisation : Gérer l'accès concurrent aux ressources partagées
Race conditions : Problèmes quand plusieurs threads modifient la même variable
Deadlocks : Blocage mutuel entre threads
Complexité : Plus difficile à déboguer qu'un programme séquentiel

12.1.2 – Thread principal (Main Thread)

Chaque programme Java démarre avec au moins un thread : le thread principal (main thread). C'est ce thread qui exécute la méthode main().

🔍 Identifier le thread principal

public class ThreadPrincipal {
    public static void main(String[] args) {
        // Obtenir une référence au thread actuel
        Thread threadActuel = Thread.currentThread();
        
        // Afficher les informations du thread
        System.out.println("Nom du thread : " + threadActuel.getName());
        System.out.println("ID du thread : " + threadActuel.getId());
        System.out.println("Priorité : " + threadActuel.getPriority());
        System.out.println("État : " + threadActuel.getState());
        
        // Le thread principal s'appelle "main"
        // Affiche : Nom du thread : main
    }
}

Caractéristiques du thread principal :

Nom : "main"
Priorité : 5 (priorité normale par défaut)
État : RUNNABLE quand il s'exécute
Démarre automatiquement avec l'exécution du programme

📊 États d'un thread

Un thread peut être dans différents états pendant son cycle de vie :

NEW : Thread créé mais pas encore démarré
RUNNABLE : Thread exécutable (en cours d'exécution ou prêt à être exécuté)
BLOCKED : Thread bloqué en attendant un verrou (lock)
WAITING : Thread en attente indéfinie
TIMED_WAITING : Thread en attente avec un délai
TERMINATED : Thread terminé

Thread thread = new Thread(() -> {
    System.out.println("Thread en cours d'exécution");
});

System.out.println("État avant start() : " + thread.getState());  // NEW

thread.start();
System.out.println("État après start() : " + thread.getState());  // RUNNABLE

// Attendre que le thread se termine
try {
    thread.join();
    System.out.println("État après join() : " + thread.getState());  // TERMINATED
} catch (InterruptedException e) {
    e.printStackTrace();
}

12.1.3 – Cas d'usage des threads

Les threads sont utilisés dans de nombreux contextes pour améliorer les performances et la réactivité des applications.

🌐 Applications web

Les serveurs web gèrent plusieurs requêtes simultanément, chaque requête étant traitée dans un thread séparé.

Exemple : Un serveur web peut traiter 100 requêtes simultanément en utilisant 100 threads différents, au lieu d'attendre que chaque requête soit terminée avant de traiter la suivante.

🎮 Applications graphiques

Les interfaces utilisateur utilisent des threads pour rester réactives pendant les opérations longues.

// Exemple conceptuel : Interface utilisateur
// Thread 1 : Interface utilisateur (reste réactive)
// Thread 2 : Calculs lourds en arrière-plan

// Sans threads : L'interface se fige pendant les calculs
// Avec threads : L'interface reste réactive pendant les calculs

📊 Traitement de données

Le traitement parallèle de grandes quantités de données peut être accéléré en divisant le travail entre plusieurs threads.

🔄 Tâches périodiques

Les threads peuvent être utilisés pour exécuter des tâches périodiques (sauvegardes automatiques, nettoyage, etc.).

💡 Points clés à retenir

Thread : Unité d'exécution indépendante
Thread principal : Exécute la méthode main()
Multi-threading : Exécution simultanée de plusieurs threads
Avantages : Performance, réactivité, parallélisme
Défis : Synchronisation, race conditions, complexité
États : NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED