Threads

Un navigateur télécharge une page pendant que vous faites défiler la précédente ; un traitement de texte vérifie l'orthographe pendant que vous tapez ; un serveur répond à des centaines de clients à la fois. Tous ces programmes font plusieurs choses en même temps. En Java, chacune de ces activités est un thread, ou fil d'exécution. Ce chapitre montre comment en créer, comment les attendre, et surtout comment éviter les pièges redoutables qui apparaissent dès que plusieurs fils partagent des données.

15.1 Processus et threads

Tout programme Java a au moins un fil : celui qui exécute main, et qui s'appelle justement main. La JVM en lance d'autres en coulisses (par exemple pour le ramasse-miettes).

Pourquoi plusieurs fils ?

• Aller plus vite : un ordinateur moderne a plusieurs cœurs de calcul ; un programme à un seul fil n'en utilise qu'un.
• Ne pas attendre : pendant qu'un fil attend une réponse du réseau ou du disque, un autre continue de travailler (ou de répondre à l'utilisateur).
• Servir plusieurs clients : un serveur consacre un fil à chaque client (chapitre 16).

15.2 Créer et démarrer un thread

Un thread est un objet de la classe java.lang.Thread. Le code qu'il exécute est celui de sa méthode run(). Il y a trois façons de le fournir.

/** Chapitre 15 — trois façons de créer un thread. */
public class TroisFacons {
    // 1) Hériter de Thread et redéfinir run()
    static class Salueur extends Thread {
        private final String texte;
        Salueur(String texte) { this.texte = texte; }
        @Override public void run() {
            for (int i = 0; i < 3; i++) System.out.println(texte + " " + i);
        }
    }

    // 2) Implémenter Runnable et confier l'objet à un Thread
    static class Compteur implements Runnable {
        @Override public void run() {
            for (int i = 0; i < 3; i++) System.out.println("Runnable " + i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread a = new Salueur("Hérité");
        Thread b = new Thread(new Compteur());
        // 3) Donner directement le code sous forme de lambda
        Thread c = new Thread(() -> {
            for (int i = 0; i < 3; i++) System.out.println("Lambda " + i);
        });
        a.start(); b.start(); c.start();      // les trois fils démarrent
        a.join(); b.join(); c.join();         // main attend leur fin
        System.out.println("Fin du main");
    }
}

Une exécution :

Lambda 0
Lambda 1
Lambda 2
Runnable 0
Runnable 1
Runnable 2
Hérité 0
Hérité 1
Hérité 2
Fin du main

Les fils ont été démarrés dans l'ordre a, b, c, et pourtant c'est c qui a fini le premier : rien ne garantit l'ordre. Seule certitude ici : « Fin du main » vient en dernier, grâce aux join.

15.2.1 L'erreur classique : run au lieu de start

/** Chapitre 15 — l'erreur classique : appeler run() au lieu de start(). */
public class StartOuRun {
    public static void main(String[] args) throws InterruptedException {
        Runnable qui = () -> System.out.println("exécuté par : " + Thread.currentThread().getName());
        Thread t = new Thread(qui, "Travailleur");
        t.run();      // appel de méthode ordinaire : c'est main qui l'exécute !
        t.start();    // nouveau fil d'exécution
        t.join();
    }
}

exécuté par : main
exécuté par : Travailleur

15.2.2 Attendre : sleep et join

Thread.sleep(ms) suspend le fil courant pendant le nombre de millisecondes indiqué, sans consommer de temps de calcul. Le programme suivant simule trois tâches d'une seconde, d'abord à la suite, puis en parallèle.

/** Chapitre 15 — sleep et join : trois tâches de 1 s en parallèle prennent 1 s, pas 3. */
public class Attente {
    static void tache(String nom) {
        try {
            Thread.sleep(1000);                       // simule un travail d'une seconde
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println(nom + " terminée");
    }

    public static void main(String[] args) throws InterruptedException {
        long debut = System.currentTimeMillis();
        tache("séquentielle 1"); tache("séquentielle 2"); tache("séquentielle 3");
        System.out.printf("En séquence : %.1f s%n", (System.currentTimeMillis() - debut) / 1000.0);

        debut = System.currentTimeMillis();
        Thread[] fils = new Thread[3];
        for (int i = 0; i < 3; i++) {
            String nom = "parallèle " + (i + 1);
            fils[i] = new Thread(() -> tache(nom));
            fils[i].start();
        }
        for (Thread t : fils) t.join();
        System.out.printf("En parallèle : %.1f s%n", (System.currentTimeMillis() - debut) / 1000.0);
    }
}