Introduction : La Promesse et le Péril des Threads

Pour comprendre la programmation concurrente, imaginez une cuisine. Un programme classique, dit mono-thread, est comme un cuisinier seul : il prépare l'entrée, puis le plat, puis le dessert, une tâche après l'autre. Un programme multi-thread, lui, est comme une équipe de cuisiniers. Ils travaillent en parallèle, chacun sur une partie de la recette, ce qui permet de préparer le repas beaucoup plus rapidement. Ces "cuisiniers" virtuels sont ce que nous appelons des threads.

Cependant, faire travailler plusieurs cuisiniers dans la même cuisine introduit des défis. Si deux cuisiniers essaient d'utiliser le même pot de sel en même temps, le chaos peut s'installer. En programmation, c'est exactement le même principe. Les threads offrent une puissance considérable, mais ils comportent aussi des risques.

• Les Avantages (La Promesse)
  • Partage efficace du processeur : La gestion du temps de calcul entre les threads est beaucoup moins coûteuse qu'entre des programmes entièrement séparés.
  • Partage simple de la mémoire : Tous les threads d'un programme partagent le même espace mémoire, leur permettant de collaborer facilement sur les mêmes données, comme notre équipe de cuisiniers qui partagent les mêmes ingrédients.
• Les Inconvénients (Le Péril)
  • Conflits d'accès : Le partage de la mémoire est un avantage, mais aussi la source principale de problèmes. Qui a le droit de modifier une donnée partagée, et à quel moment ? C'est une question cruciale à régler.
  • Fragilité de l'application : Si un seul thread rencontre une erreur fatale et "plante", c'est toute l'application (toute la cuisine) qui s'arrête.

Pour bien comprendre ce péril, nous allons maintenant explorer un cas pratique simple mais révélateur : la classe Box. Nous allons observer directement comment deux threads, nos deux "cuisiniers", peuvent créer un désordre complet en manipulant une "boîte" partagée, et surtout, comment nous pouvons y remettre de l'ordre.

1. Le Scénario : Mise en Place de l'Expérience

Cette promesse de performance et les risques qu'elle engendre nous amènent à notre scénario d'expérimentation. Pour notre expérience, nous avons besoin de trois éléments : un objet partagé, des "travailleurs" (threads) qui vont le manipuler, et un programme principal pour lancer le tout.

L'Objet Partagé : La Classe Box

Voici notre "ingrédient" commun. C'est une simple boîte numérique qui contient une seule valeur, val. On peut lire cette valeur avec la méthode get() et l'augmenter avec increment().

public class Box {
    public int val;
    public Box() {
       val = 0;
    }

    public int get() {
       return val;
    }

    public void increment(int incVal) {
       val += incVal;
       System.out.println("after inc : " + val);
    }
}

Les Acteurs : La Classe ThreadIncShared

Chaque instance de cette classe est un "travailleur". Sa mission, définie dans la méthode run(), est simple : lire la valeur actuelle de la Box, l'afficher, puis l'incrémenter. Il répète cette opération cinq fois. Le point crucial est que chaque thread reçoit une référence vers la même et unique instance de Box. Il est important de noter la différence entre la variable b.val (la donnée partagée dans la Box) et la variable locale val dans la méthode run(), qui n'est qu'une copie temporaire de la valeur à un instant T.

public class ThreadIncShared extends Thread {
    public int id, incVal;
    public Box b;

    public ThreadIncShared(int id, int incVal, Box b) {
       this.id = id;
       this.incVal = incVal;
       this.b = b;
    }

    public void run() {
       System.out.println("I am thread " + id);
       int val;
       for(int i=0; i<5; i++) {
          val = b.get();
          System.out.println("T" + id + " - " + val);
          b.increment(incVal);
       }
       System.out.println("I die ");
    }
}

Le Programme Principal : La Classe TestThreadIncShared

Ce code met en place notre scène. Il crée une seule Box, puis deux threads, t1 et t2.

• t1 aura pour mission d'ajouter 2 à chaque boucle.
• t2 aura pour mission d'ajouter 5 à chaque boucle.

Ensuite, il les lance simultanément avec la méthode start().

public class TestThreadIncShared {
    public static void main(String[] args) {
       Box b = new Box();

       ThreadIncShared t1,t2;
       t1 = new ThreadIncShared(1,2,b);
       t2 = new ThreadIncShared(2,5,b);
       t1.start();
       t2.start();
    }
}