Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Apprendre Threads en Java | Principes de Base du Multithreading
Multithreading en Java

bookThreads en Java

Par exemple, imaginez que votre programme possède un thread principal chargé d’afficher l’interface utilisateur. En même temps, vous pouvez créer un thread supplémentaire pour charger des données depuis le réseau ou effectuer des calculs complexes. Cela permet de rendre le programme plus réactif et efficace.

Déclaration d’un thread en Java

Avec la classe Thread : il est possible de créer une sous-classe de la classe Thread et de redéfinir la méthode run() , qui contient le code exécuté dans le nouveau thread.

Main.java

Main.java

copy

              
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, il est possible d'implémenter l'interface Runnable, de fournir une méthode run() et de la transmettre au constructeur de la classe Thread.

Main.java

Main.java

copy

              
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

Une autre approche consiste à hériter de la classe Thread et à surcharger la méthode run().

Main.java

Main.java

copy

              
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

Il est également possible d’implémenter l’interface Runnable et d’y définir la méthode run() :

Main.java

Main.java

copy

              
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
    }
}
Note
Remarque

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

Différence entre Thread et Runnable

En Java, un Thread est un canal particulier qui permet l’exécution concurrente de tâches, offrant la possibilité à 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. Il est possible de passer une implémentation de Runnable au constructeur d’un Thread afin d’exécuter la tâche dans un nouveau thread. Cette méthode facilite la gestion et l’exécution efficace de tâches parallèles.

Méthodes disponibles pour les threads en Java

Démarrage d’un thread à l’aide de la méthode start(), indiquant 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 n’attend pas que le thread nouvellement démarré se termine.

Main.java

Main.java

copy

              
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 disposons également d'une méthode permettant au thread principal d'attendre la fin d'exécution du thread qu'il a démarré, en utilisant la méthode join(). Cette méthode attend que le thread soit entièrement exécuté. Il est possible de vérifier si le thread est actuellement en cours d'exécution en utilisant la méthode isAlive().

Le code Thread.sleep(5000) suspend le thread pendant 5000 millisecondes (5 secondes).

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
}

Dans l'exemple, avant d'appeler join(), le thread était en cours d'exécution. Après l'appel à join(), il ne l'est plus, car join() signifie que l'on va attendre à cet endroit jusqu'à ce que le thread termine son exécution.

Si l'on souhaite arrêter un thread, il est possible d'utiliser la méthode interrupt(). Cependant, pour que cela fonctionne, il est nécessaire de vérifier si le thread que l'on souhaite arrêter est interrompu.

Main.java

Main.java

copy

              
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 dans une boucle jusqu'à ce qu'il soit interrompu. Lorsque le thread est interrompu pendant qu'il est en sommeil, il lève une exception, la gère en réinitialisant le drapeau d'interruption, puis se termine.

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

Note
Remarque

Ces méthodes 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 prochains chapitres, nous approfondirons 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 ?

question mark

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

Select the correct answer

question mark

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

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 3

Demandez à l'IA

expand

Demandez à l'IA

ChatGPT

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain the difference between extending the Thread class and implementing the Runnable interface?

How does the start() method work in Java threads?

What happens if I call the run() method directly instead of start()?

Awesome!

Completion rate improved to 3.33

bookThreads en Java

Glissez pour afficher le menu

Par exemple, imaginez que votre programme possède un thread principal chargé d’afficher l’interface utilisateur. En même temps, vous pouvez créer un thread supplémentaire pour charger des données depuis le réseau ou effectuer des calculs complexes. Cela permet de rendre le programme plus réactif et efficace.

Déclaration d’un thread en Java

Avec la classe Thread : il est possible de créer une sous-classe de la classe Thread et de redéfinir la méthode run() , qui contient le code exécuté dans le nouveau thread.

Main.java

Main.java

copy

              
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, il est possible d'implémenter l'interface Runnable, de fournir une méthode run() et de la transmettre au constructeur de la classe Thread.

Main.java

Main.java

copy

              
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

Une autre approche consiste à hériter de la classe Thread et à surcharger la méthode run().

Main.java

Main.java

copy

              
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

Il est également possible d’implémenter l’interface Runnable et d’y définir la méthode run() :

Main.java

Main.java

copy

              
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
    }
}
Note
Remarque

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

Différence entre Thread et Runnable

En Java, un Thread est un canal particulier qui permet l’exécution concurrente de tâches, offrant la possibilité à 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. Il est possible de passer une implémentation de Runnable au constructeur d’un Thread afin d’exécuter la tâche dans un nouveau thread. Cette méthode facilite la gestion et l’exécution efficace de tâches parallèles.

Méthodes disponibles pour les threads en Java

Démarrage d’un thread à l’aide de la méthode start(), indiquant 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 n’attend pas que le thread nouvellement démarré se termine.

Main.java

Main.java

copy

              
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 disposons également d'une méthode permettant au thread principal d'attendre la fin d'exécution du thread qu'il a démarré, en utilisant la méthode join(). Cette méthode attend que le thread soit entièrement exécuté. Il est possible de vérifier si le thread est actuellement en cours d'exécution en utilisant la méthode isAlive().

Le code Thread.sleep(5000) suspend le thread pendant 5000 millisecondes (5 secondes).

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
}

Dans l'exemple, avant d'appeler join(), le thread était en cours d'exécution. Après l'appel à join(), il ne l'est plus, car join() signifie que l'on va attendre à cet endroit jusqu'à ce que le thread termine son exécution.

Si l'on souhaite arrêter un thread, il est possible d'utiliser la méthode interrupt(). Cependant, pour que cela fonctionne, il est nécessaire de vérifier si le thread que l'on souhaite arrêter est interrompu.

Main.java

Main.java

copy

              
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 dans une boucle jusqu'à ce qu'il soit interrompu. Lorsque le thread est interrompu pendant qu'il est en sommeil, il lève une exception, la gère en réinitialisant le drapeau d'interruption, puis se termine.

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

Note
Remarque

Ces méthodes 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 prochains chapitres, nous approfondirons 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 ?

question mark

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

Select the correct answer

question mark

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

Select the correct answer

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 3
some-alt