Threads en Java

Par exemple, imaginez que votre programme a un fil principal responsable de l'affichage de l'interface utilisateur. En même temps, vous pouvez créer un fil supplémentaire pour charger des données depuis le réseau ou effectuer des calculs complexes. Cela aide à rendre le programme plus réactif et efficace.

Comment déclarer un thread en Java

En utilisant la classe Thread

Avec la Thread: classe, vous pouvez créer une sous-classe de la classe Thread et remplacer la méthode run() , qui contient le code qui sera exécuté dans le nouveau thread.

Main


              123456789
            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Utilisation de l'interface Runnable

Avec l'interface Runnable, vous pouvez implémenter l'interface Runnable, fournir une méthode run() et la passer au constructeur de la classe Thread.

Main


              123456789101112
            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Héritage de la classe Thread

Alternativement, vous pouvez hériter de la classe Thread et surcharger la méthode run().

Main


              123456789
            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implémentation de l'interface Runnable

Vous pouvez également implémenter l'interface Runnable et y implémenter la méthode run() :

Main


              123456789
            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Remarque

La méthode run() dans un thread Java vous permet d'exécuter du code dans un thread séparé, y compris des tâches comme le traitement de données, les calculs, le téléchargement de fichiers, et l'envoi ou la réception de données sur le réseau.

Quelle est la différence entre Thread et Runnable?

En Java, un Thread est un canal spécial qui permet l'exécution concurrente de tâches, permettant à votre programme d'effectuer des opérations dans un thread séparé, telles que des calculs ou des processus de longue durée comme le chargement de données.

L'interface Runnable, avec sa seule méthode run(), définit une tâche à exécuter par un thread. Vous pouvez passer une implémentation de Runnable à un constructeur de Thread pour exécuter la tâche dans un nouveau thread. Cette méthode aide à gérer et exécuter des tâches parallèles efficacement.

Quelles méthodes existent pour les threads en Java?

Commençons par démarrer un thread en utilisant la méthode start(), ce qui indique que le code doit s'exécuter dans un nouveau thread. Cela signifie que le thread principal continue d'exécuter son propre code et ne pas attendre que le thread nouvellement démarré se termine.

Main


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Nous avons également une méthode pour que le thread principal attende l'exécution du thread qu'il a démarré en utilisant la méthode join(). Cette méthode attend jusqu'à ce que le thread soit entièrement exécuté. Vous pouvez vérifier si le thread est actuellement en cours d'exécution en utilisant la méthode isAlive().

Le code Thread.sleep(5000) met en pause le thread pendant 5000 millisecondes (5 secondes).

Dans l'exemple, avant d'appeler join(), le thread était en cours de travail. Après avoir appelé join(), il ne l'est pas, car join() signifie que nous allons attendre à ce point jusqu'à ce que le thread termine son exécution.

Si nous voulons arrêter un thread, nous pouvons utiliser la méthode interrupt(). Cependant, pour que cela fonctionne, nous devons vérifier si le thread que nous arrêtons est interrompu.

Main


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Cet exemple crée un thread qui exécute une tâche en boucle jusqu'à ce qu'il soit interrompu. Lorsque le thread est interrompu pendant qu'il dort, il lance une exception, la gère en définissant le drapeau d'interruption, puis se termine.

Sans gestionnaire d'exception InterruptedException dans le thread, le thread ne serait pas interrompu.

Remarque

Ces méthodes vous permettent de gérer le cycle de vie et l'exécution des threads en Java, offrant flexibilité et contrôle sur les applications multithreadées. Dans les chapitres suivants, nous explorerons davantage ces méthodes.

1. Qu'est-ce qu'un thread en Java ?

2. Quelle est la différence entre la classe Thread et l'interface Runnable en Java ?

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 3