Cours Thread et Communication en Java

La première méthode pour créer un thread consiste à créer une classe qui hérite de la class Thread. Cette classe doit surcharger la méthode run() de la classe Thread.

class MonThread extends Thread {
    MonThread() {
            ... code du constructeur ...
    }

    public void run() {
            ... code a executer dans le thread ...
    }
}

Une instance de Thread est lancée en appelant la méthode start() définie par la classe Thread :

MonThread p = new MonThread();
p.start();

L'appel de la méthode start() passe le thread à l'état « prêt », ce qui lui permet de démarrer dès que possible (mais pas nécessairement immédiatement). C'est la machine virtuelle JAVA qui décide du moment auquel le thread va s'exécuter. Lorsque le thread démarre, JAVA appelle sa méthode run().

Un thread se termine lorsque sa méthode run() termine.

L'autre moyen de créer un thread est de déclarer une classe qui implémente l'interface Runnable. Cette interface déclare seulement une méthode : run().

La classe Thread a un créateur qui prend une instance implémentant Runnable en argument.

La classe se déclare comme dans l'exemple précédent, mais on implémente Runnable au lieu d'hériter de Thread :

class MonThread2 implements Runnable {
    MonThread2() {
        ... code du constructeur ...
    }

    public void run() {
        ... code a executer dans le thread ...
    }
}

Pour créer et lancer un thread, on crée d'abord une instance de notre classe MonThread2, puis une instance de Thread sur laquelle on appelle la méthode start(), comme dans l'exemple suivant :

public static void main(String[] args)  {
        MonThread2 p = new MonThread2();
        Thread t = new Thread(p);
        t.start();
}

Considérons le problème classique suivant :

//: exempleConcurrent.java
public class exempleConcurrent extends Thread {

        private static int compte = 0;

    public void run() {
                int tmp = compte;
                try {
                        Thread.sleep(1); // ms
                } catch (InterruptedException e) {
                        System.out.println("ouch!\n");
                        return;
                }
                tmp = tmp + 1;
                compte = tmp;
    }

    public static void main(String args[]) throws InterruptedException {
                Thread T1 = new exempleConcurrent();
                Thread T2 = new exempleConcurrent();
                T1.start();
                T2.start();
                T1.join();
                T2.join();
        System.out.println( "compteur=" + compte );
    }
}

Les deux threads T1 et T2 accèdent à une même variable partagée compte, travaillent sur une copie locale tmp qui est incrémentée avant d'être réécrite dans compte. Nous avons intercalé un appel à sleep pour simuler un traitement plus long et augmenter la probabilité que le système bascule d'une tâche à l'autre durant l'exécution de run.

Les problèmes d'accès concurrents se règlent en JAVA à l'aide du mot clé synchronized, qui permet de déclarer qu'une méthode ou un bloc d'instructions est critique : un seul thread à la fois peut se trouver dans une partie synchronisée sur un objet.

Ce mécanisme est implémenté par la machine virtuelle JAVA à l'aide d'un verrou (lock, en fait un sémaphore). Chaque objet JAVA possède un verrou. Pour exécuter une section de code synchronisée (bloc ou méthode), il faut posséder le verrou. Si un thread commence à exécuter une section synchronisée, aucun autre thread ne pourra entrer dans une section synchronisée du même objet (même par une autre méthode) tant que le verrou n'aura pas été libéré (en quittant la partie synchronisée ou en appelant la méthode wait() que nous étudions plus loin).

Attention, si l'on veut synchroniser une méthode pour tous les objets de cette classe (accès à des variables de classes partagées par plusieurs threads), il faut que la méthode synchronisée soit une méthode de classe (static).

Les méthodes wait(), notify() et notifyAll() permettent de synchroniser différents threads. Ces méthodes sont définies dans la classe Object (car elles manipulent le verrou associé à un objet), mais ne doivent s'utiliser que dans des méthodes synchronized.

1. wait() : le thread qui appelle cette méthode est bloqué jusqu'à ce qu'un autre thread appelle notify() ou notifyAll(). Notons que wait() libère le verrou, ce qui permet à d'autres threads d'exécuter des méthodes synchronisées du même objet.
2. notify() et notifyAll() permettent de débloquer une tâche bloquée par wait(). Attention, si une tâche T1 appelle wait dans une méthode de l'objet O, seule une autre méthode du même objet pourra la débloquer; cette méthode devra être synchronisée et exécutée par une autre tâche T2.

Exemple : implémentation d'une classe Evenement

//: Evenement.java
// Classe simulant la notion d'événement
//      S. Szulman 1998
public class Evenement
{
        private Boolean Etat; // etat de l'evenement 
        public Evenement() {
                Etat = Boolean.FALSE;
        }
        public synchronized void set() {
                Etat = Boolean.TRUE;
        // debloque les threads qui attendent cet evenement:
                notifyAll();
        }
        public synchronized void reset() {
                Etat = Boolean.FALSE;
        }
        public synchronized void attente() {
                if(Etat==Boolean.FALSE) {
                        try {
                                wait(); // bloque jusqu'a un notify()
                        }
                        catch(InterruptedException e) {};
                }
        }// fin attente
}// fin classe

La synchronisation entre tâches est un art difficile : si l'on ne synchronise pas assez, des résultats erronés peuvent se produire (qui plus est de façon pas toujours reproductible), mais si l'on synchronise mal les traitements, on risque de pénaliser les performances : l'entrée dans une méthode synchonized est coûteuse (prise du verrou), et on perd les avantages des traitements en parallèle. D'autre part, un mécanisme de synchronisation mal conçu entraîne facilement l'apparition d'interblocages (deadlocks) : plusieurs tâches peuvent s'attendre mutuellement, et plus rien ne se passe.

L'ancienne API de JAVA possédait plusieurs autres méthodes de synchronisation qui ont été supprimées (en fait elles sont deprecated, c'est-à-dire qu'elles existent toujours pour que les anciens programmes fonctionnent, mais que leur emploi est fortement déconseillé et déclenche un message du compilateur). À l'usage, les développeurs se sont en effet rendu compte que l'usage de ces méthodes (stop, suspend, resume, destroy) entraînait souvent l'apparition d'interblocages.

Il est très courant d'enchaîner plusieurs commandes UNIX lancées depuis le shell. Ainsi, lorsqu'on entre :

$ ps -au | grep napster

le système lance deux processus, le premier exécutant la commande ps et le second la commande grep. La sortie standard de ps est redirigée dans un tube, qui la relie à l'entrée standard de grep.

Les tubes UNIX permettent de relier deux processus issus d'un même ancêtre, qui doit créer le tube à l'aide de l'appel système pipe(). L'appel pipe() retourne deux descripteurs d'entrées/sorties, l'un pour écrire (l'entrée du tube), l'autre pour lire (la sortie du tube). On peut ensuite créer un ou plusieurs processus fils à l'aide l'appel système fork(). Les processus fils héritent alors des descripteurs et peuvent donc utiliser le tube.

Notons que le système UNIX propose un autre type de tube, les tubes nommés (ou FIFO), qui correspondent à un fichier dans le système de fichiers, et permettent l'établissement d'une connexion entre deux processus quelconques s'exécutant sur la même machine. Ce type de tube est relativement peu utilisé (on préfère souvent utiliser des sockets) et nous ne les étudierons pas dans ce cours.

La fonction C popen() permet de lancer une commande UNIX reliée à son processus père par un tube. Cette fonction est pratique, car elle se charge de la création du tube et du processus fils (popen() appelle donc pipe() et fork()). Le prototype de popen est :

FILE *popen( char *command, char *mode );

où command spécifie la commande à lancer (avec éventuellement ses arguments) et mode le sens de la communication : « w » si l'on écrit dans le tube (c'est-à-dire que l'on envoie des données vers la commande lancée), « r » si on lit depuis le tube.

Notez la similitude entre popen() et la fonction fopen() qui ouvre un fichier : ces deux commandes retournent en pointeur sur une structure FILE, que l'on peut employer avec les fonctions d'entrées/sorties habituelles comme fread(), fwrite(), fgets(), fprintf(), etc.

Un tube ouvert par popen() doit être fermé en appelant la fonction pclose() (à la place de fclose() pour un fichier).