Exemple de thread Java

Bienvenue dans l’exemple de thread Java. Processus et Thread sont deux unités d’exécution de base. La programmation concurrente est plus concernée par les threads Java.

Processus

A process is a self contained execution environment and it can be seen as a program or application. However a program itself contains multiple processes inside it. Java runtime environment runs as a single process which contains different classes and programs as processes.

Thread

Le thread peut être appelé processus léger. Le thread nécessite moins de ressources pour être créé et existe dans le processus, il partage les ressources du processus.

Exemple de thread Java

Chaque application Java a au moins un thread – le thread principal. Bien qu’il existe de nombreux autres threads Java s’exécutant en arrière-plan, tels que la gestion de la mémoire, la gestion du système, le traitement des signaux, etc. Mais du point de vue de l’application, le thread principal est le premier thread Java et nous pouvons créer plusieurs threads à partir de celui-ci. La programmation multithread fait référence à l’exécution simultanée de deux ou plusieurs threads dans un seul programme. Un processeur monocœur d’ordinateur ne peut exécuter qu’un seul thread à la fois et le partage de temps est une fonctionnalité du système d’exploitation pour partager le temps du processeur entre différents processus et threads.

Avantages des threads Java

1. Les threads Java sont légers par rapport aux processus, ils nécessitent moins de temps et de ressources pour créer un thread.
2. Les threads partagent les données et le code de leur processus parent
3. Le changement de contexte entre les threads est généralement moins coûteux que entre les processus.
4. La communication entre les threads est relativement plus facile que la communication entre les processus.

Java propose deux façons de créer un thread de manière programmative.

1. Implémentation de l’interface java.lang.Runnable.
2. Extension de la classe java.lang.Thread.

Exemple de Thread Java – implémentation de l’interface Runnable

Pour rendre une classe exécutable, nous pouvons implémenter l’interface java.lang.Runnable et fournir une implémentation dans la méthode public void run(). Pour utiliser cette classe en tant que Thread, nous devons créer un objet Thread en passant un objet de cette classe exécutable, puis appeler la méthode start() pour exécuter la méthode run() dans un thread séparé. Voici un exemple de thread Java en implémentant l’interface Runnable.

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Obtenir une connexion à la base de données, supprimer les données inutilisées de la base de données
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }

}

Exemple de Thread Java – extension de la classe Thread

Nous pouvons étendre la classe java.lang.Thread pour créer notre propre classe de thread Java et remplacer la méthode run(). Ensuite, nous pouvons créer un objet de cette classe et appeler la méthode start() pour exécuter notre méthode de thread Java personnalisée. Voici un exemple simple de thread Java montrant comment étendre la classe Thread.

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("MyThread - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Obtenir une connexion à la base de données, supprimer les données inutilisées de la base de données
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("MyThread - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
    
}

Voici un programme de test montrant comment créer un thread Java et l’exécuter.

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args){
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started");
        
    }
}

La sortie du programme d’exemple de thread Java ci-dessus est :

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

Une fois que nous démarrons un thread, son exécution dépend de l’implémentation du temps de découpage par le système d’exploitation et nous ne pouvons pas contrôler leur exécution. Cependant, nous pouvons définir la priorité des threads, mais cela ne garantit pas que le thread de priorité plus élevée sera exécuté en premier. Exécutez le programme ci-dessus plusieurs fois et vous verrez qu’il n’y a pas de modèle de début et de fin des threads.

Runnable vs Thread

Si votre classe offre plus de fonctionnalités que simplement s’exécuter en tant que thread, vous devez implémenter l’interface Runnable pour lui permettre de s’exécuter en tant que thread. Si le seul but de votre classe est de s’exécuter en tant que thread, vous pouvez étendre la classe Thread. L’implémentation de Runnable est préférée car Java prend en charge l’implémentation de plusieurs interfaces. Si vous étendez la classe Thread, vous ne pouvez pas étendre d’autres classes.
Conseil: Comme vous l’avez remarqué, le thread ne renvoie aucune valeur, mais que faire si nous voulons que notre thread effectue un traitement et renvoie ensuite le résultat à notre programme client ? Consultez notre Java Callable Future.
Mise à jour: À partir de Java 8, Runnable est une interface fonctionnelle et nous pouvons utiliser des expressions lambda pour fournir son implémentation plutôt que d’utiliser une classe anonyme. Pour plus de détails, consultez les Interfaces fonctionnelles Java 8.