CodeGym /Cours /JAVA 25 SELF /Introduction au multithreading : pourquoi en a-t-on besoi...

Introduction au multithreading : pourquoi en a-t-on besoin

JAVA 25 SELF
Niveau 51, Leçon 0
Disponible

1. Qu’est-ce qu’un fil d’exécution (thread)

Un thread comme ligne de travail autonome

En Java (et en programmation en général), un fil d’exécution est une séquence d’instructions indépendante qui s’exécute en parallèle avec d’autres threads au sein d’un même programme. Imaginez une usine : chaque couturière a son propre poste et sa tâche, elle travaille de façon indépendante, mais tout contribue au résultat commun.

Par défaut, un programme Java démarre avec un seul thread — celui qui lance la méthode main. Mais rien ne nous empêche de créer des threads supplémentaires afin que différentes parties du programme s’exécutent simultanément.

Processus et threads : quelle est la différence ?

  • Processus — une unité d’exécution « lourde ». Chaque processus possède son propre espace mémoire, ses variables et ses ressources. Les processus sont totalement isolés les uns des autres : si l’un tombe en panne, les autres ne sont pas affectés.
  • Thread — une unité d’exécution « légère » au sein d’un processus. Tous les threads d’un même processus partagent la mémoire et les ressources. Cela signifie qu’ils peuvent échanger facilement des données (et, hélas, aussi se gêner mutuellement).

Analogie :
Un processus, c’est un appartement séparé : chacun a ses murs et ses occupants.
Les threads, ce sont les occupants d’un même appartement : chacun a ses activités, mais la cuisine et la salle de bain sont communes.

À quoi cela ressemble-t-il en Java ?

Quand vous lancez un programme, la JVM crée au moins un thread — le principal (main). Mais vous pouvez créer de nouveaux threads pour exécuter des tâches en parallèle.

2. Pourquoi a-t-on besoin du multithreading

Réactivité : l’UI ne doit pas « se figer »

Supposons que vous écriviez une application graphique — par exemple, un éditeur de texte. L’utilisateur clique sur le bouton « Enregistrer », et vous commencez à écrire longuement le fichier sur le disque. Si tout cela se fait dans le thread principal, la fenêtre de l’application va « geler » : l’utilisateur ne pourra rien cliquer, le curseur ne bougera pas, l’interface ne réagira pas. Si, au contraire, vous enregistrez le fichier dans un thread séparé, l’interface reste réactive et l’utilisateur peut même changer d’avis et fermer l’application.

Exemple concret :
Vous ouvrez un navigateur et commencez à télécharger un gros fichier. Si le navigateur n’utilisait pas de threads, vous ne pourriez ni ouvrir un nouvel onglet, ni faire défiler la page avant la fin du téléchargement !

Traitement des données en parallèle

Supposons que vous ayez une liste de mille fichiers à traiter (par exemple, recalculer des hachages ou remplacer du texte). Pourquoi ne pas les traiter en parallèle ? Chaque thread prend son fichier et travaille indépendamment, et l’ensemble du travail s’achève beaucoup plus vite.

Exemple :
Un serveur traite les requêtes de centaines de clients. S’il faisait cela dans un seul thread, les autres clients attendraient indéfiniment leur tour. Avec des threads, chaque requête est traitée indépendamment !

Utilisation des processeurs multicœurs

Les processeurs modernes ne sont pas un seul « cerveau », mais une véritable équipe (des cœurs) qui peuvent travailler en parallèle. Si votre programme n’utilise qu’un seul thread, les autres cœurs s’ennuient. Si vous lancez plusieurs threads, tous les cœurs sont occupés et le programme s’exécute plus rapidement.

Fait intéressant :
Même votre téléphone a plusieurs cœurs, et les ordinateurs portables et les serveurs — des dizaines ! Ne pas les utiliser, c’est comme acheter un bus et rouler seul dedans.

3. Exemples concrets

Domaine Exemple de multithreading
Téléchargement de fichiers Télécharger plusieurs fichiers simultanément
Interface utilisateur L’application ne « se fige » pas lors du chargement/enregistrement des données
Serveurs Traitement parallèle d’un grand nombre de requêtes réseau
Jeux Threads distincts pour la physique, les graphismes, la musique, l’IA
Messageries Réception des messages, envoi de fichiers, mise à jour de l’interface
Traitement vidéo Traitement des images en parallèle

Mini-analogie :
Le cuisinier prépare la soupe, pendant que le four cuit le gâteau et que le robot aspirateur nettoie le sol — tout se passe en même temps, et le dîner est prêt plus vite !

4. Difficultés potentielles du multithreading

Condition de concurrence (race condition)
Lorsque plusieurs threads modifient simultanément la même variable, le résultat peut être imprévisible. Par exemple, si deux threads incrémentent en même temps un compteur partagé, la valeur finale peut être incorrecte. Nous en parlerons plus en détail dans une prochaine leçon.

Synchronisation
Pour éviter que les threads ne se gênent, il faut définir des règles — qui peut modifier les données et quand. C’est ce qu’on appelle la synchronisation. Pour cela, il existe des mots-clés et des constructions spécifiques (synchronized, verrous, etc.), que nous verrons plus tard.

Deadlock (blocage mutuel)
Parfois, les threads peuvent « s’apprécier » au point de s’attendre mutuellement indéfiniment, et le programme se fige. C’est ce qu’on appelle un deadlock — l’une des erreurs les plus retorses du multithreading.

Débogage et tests
Les erreurs dans les programmes multithreads sont très difficiles à traquer : parfois tout fonctionne, parfois non. Il arrive qu’un bug ne se manifeste que sur le serveur ou chez l’utilisateur, alors que chez vous tout est parfait. Cela rend les tests et le débogage du code multithreadés particulièrement délicats.

5. Aperçu rapide : à quoi ressemble un programme multithread

Exemple sans threads :

public class Main {
    public static void main(String[] args) {
        // On compte jusqu’à 5
        for (int i = 1; i <= 5; i++) {
            System.out.println(i);
        }
        // On affiche les lettres
        for (char c = 'A'; c <= 'E'; c++) {
            System.out.println(c);
        }
    }
}

La sortie est toujours identique :

1
2
3
4
5
A
B
C
D
E

Exemple avec threads :

public class Main {
    public static void main(String[] args) {
        Thread numbers = new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                System.out.println(i);
                try {
                    Thread.sleep(100); // On attend un peu
                } catch (InterruptedException e) {
                    // On ignore
                }
            }
        });

        Thread letters = new Thread(() -> {
            for (char c = 'A'; c <= 'E'; c++) {
                System.out.println(c);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    // On ignore
                }
            }
        });

        numbers.start();
        letters.start();
    }
}

La sortie sera entremêlée :

1
A
2
B
3
C
4
D
5
E

ou, si les threads « se disputent », l’ordre peut être différent. L’essentiel — les deux boucles s’exécutent en parallèle !

6. Subtilités utiles

Schéma visuel : comment les threads travaillent ensemble

+-------------------+     +-------------------+
|   Thread principal   |     |    Deuxième thread   |
+-------------------+     +-------------------+
| 1 | 2 | 3 | 4 | 5 |     | A | B | C | D | E |
+-------------------+     +-------------------+
        |                         |
        |    Les deux travaillent |
        |        en même temps    |
        +-------------------------+

Où Java utilise des threads « sous le capot »

  • Ramasse-miettes (Garbage Collector) — un thread séparé nettoie les objets non utilisés.
  • Entrée/sortie (I/O) — lecture et écriture de fichiers, connexions réseau.
  • Serveurs et applications web — chaque requête client est traitée dans un thread séparé.
  • Timers, planificateurs de tâches — exécution de tâches planifiées.

7. Erreurs typiques des débutants

Erreur n° 1 : penser que les threads accélèrent toujours le programme.
En réalité, si vous avez une machine monoprocesseur ou si vous organisez mal le travail, le multithreading peut seulement ralentir l’exécution à cause de la « confusion » et du coût des changements de contexte entre threads.

Erreur n° 2 : ignorer les problèmes de synchronisation.
Beaucoup pensent : « Je ne fais que lancer deux threads, qu’est-ce qui pourrait mal se passer ? » Mais si les deux threads modifient la même variable, le résultat peut être totalement inattendu.

Erreur n° 3 : utiliser des threads pour tout et n’importe quoi.
Inutile de lancer un thread pour chaque éternuement. Les threads sont une ressource, et leur nombre excessif peut mener à des ralentissements, voire au crash du programme.

Erreur n° 4 : absence de gestion des erreurs.
Les threads peuvent lever des exceptions (par exemple lors d’opérations fichiers ou réseau). Si vous ne gérez pas ces erreurs, le programme peut se terminer brutalement ou « se figer ».

1
Mission
JAVA 25 SELF, niveau 51, leçon 0
Bloqué
Identifier le protagoniste principal du programme 🕵️‍♀️
Identifier le protagoniste principal du programme 🕵️‍♀️
1
Mission
JAVA 25 SELF, niveau 51, leçon 0
Bloqué
Instructions pour l'assistant robot 🤖
Instructions pour l'assistant robot 🤖
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION