Java - Contrôle des Threads

Bonjour à tous, futurs magiciens Java ! Aujourd'hui, nous plongeons dans le monde fascinant du contrôle des threads en Java. Ne vous inquiétez pas si vous êtes nouveaux dans la programmation - je vais vous guider à travers ce voyage pas à pas, comme j'ai fait pour des centaines d'étudiants au fil des ans. Alors, prenez votre baguette virtuelle (clavier), et c'est parti pour un peu de magie de codage !

Qu'est-ce qu'un Thread ?

Avant de se lancer dans le contrôle des threads, comprenstons ce qu'est un thread. Imaginez que vous êtes dans une cuisine, en train de préparer un repas complexe. Vous êtes le programme principal, et chaque tâche que vous accomplissez (couper les légumes, remuer la sauce, vérifier le four) est comme un thread. Ils font tous partie du même processus global (faire à manger), mais ce sont des tâches distinctes qui peuvent se dérouler concurrentement.

En Java, un thread est un sous-processus léger, la plus petite unité de traitement. C'est un moyen de créer un chemin d'exécution séparé pour une tâche spécifique dans votre programme.

Pourquoi contrôler les Threads ?

Maintenant, pourquoi voudrions-nous contrôler ces threads ? Reprenons notre analogie culinaire. Parfois, vous devez arrêter de remuer la sauce pour vérifier le rôti. Ou vous pourriez devoir attendre que l'eau bouille avant d'ajouter les pâtes. De même, en programmation, nous devons souvent contrôler le déroulement et le timing des différents threads pour nous assurer que notre programme fonctionne en douceur et efficacement.

Méthodes pour Contrôler les Threads Java

Java propose plusieurs méthodes pour contrôler les threads. Jetons un coup d'œil à celles-ci dans un tableau pratique :

Méthode	Description
start()	Démarre le thread, provoquant l'appel de la méthode run()
run()	Contient le code constituant la tâche du thread
sleep()	Fait pause le thread pendant une durée spécifiée
join()	Attend que le thread se termine
yield()	Fait une pause temporaire pour permettre à d'autres threads de s'exécuter
interrupt()	Interrompt le thread, provoquant l'arrêt de son exécution
isAlive()	Vérifie si le thread est toujours en cours d'exécution

Maintenant, plongeons dans chacun de ces méthodes avec quelques exemples !

1. start() et run()

Ces deux méthodes travaillent main dans la main. Voici un exemple simple :

public class MonThread extends Thread {
public void run() {
System.out.println("Mon thread est en cours d'exécution !");
}

public static void main(String args[]) {
MonThread thread = new MonThread();
thread.start();
}
}

Dans cet exemple, nous créons un nouveau thread et appelons sa méthode start(). Cela appelle à son tour la méthode run(), qui contient le code que le thread exécutera.

2. sleep()

La méthode sleep() est comme appuyer sur le bouton de la minuterie sur votre réveil. Elle fait pause l'exécution du thread pendant une durée spécifiée. Voici comment cela fonctionne :

public class ThreadEndormi extends Thread {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.println("Le thread compte : " + i);
try {
Thread.sleep(1000); // Pause de 1 seconde
} catch (InterruptedException e) {
System.out.println("Le thread a été interrompu !");
}
}
}

public static void main(String args[]) {
ThreadEndormi thread = new ThreadEndormi();
thread.start();
}
}

Ce thread comptera de 1 à 5, en pause pendant une seconde entre chaque comptage. C'est comme une personne somnolente comptant lentement les moutons !

3. join()

La méthode join() est comme attendre que votre ami finisse sa tâche avant d'aller déjeuner. Elle fait attendre le thread courant jusqu'à ce que le thread auquel il est joint ait terminé son exécution. Voici un exemple :

public class ExempleJoin {
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Thread 1 : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});

Thread t2 = new Thread(() -> {
try {
t1.join(); // Attendre que t1 se termine
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread 2 : J'ai fini d'attendre !");
});

t1.start();
t2.start();
}
}

Dans cet exemple, Thread 2 attend que Thread 1 se termine avant d'afficher son message.

4. yield()

La méthode yield() est comme être poli dans une conversation - elle suggère que le thread peut faire une pause pour permettre à d'autres threads de même priorité de s'exécuter. Cependant, c'est juste un indice pour le planificateur, et il peut être ignoré. Voici un exemple simple :

public class ExempleYield implements Runnable {
public void run() {
for (int i = 0; i < 3; i++) {
System.out.println(Thread.currentThread().getName() + " en contrôle");
Thread.yield();
}
}

public static void main(String[] args) {
Thread t1 = new Thread(new ExempleYield(), "Thread 1");
Thread t2 = new Thread(new ExempleYield(), "Thread 2");
t1.start();
t2.start();
}
}

Vous pourriez voir les threads alterner le contrôle, mais souvenez-vous, ce n'est pas garanti !

5. interrupt()

La méthode interrupt() est comme taper doucement someone sur l'épaule pour attirer son attention. Elle ne stoppe pas immédiatement le thread mais met un drapeau que le thread peut vérifier. Voici comment cela fonctionne :

public class Exemple Interruption implements Runnable {
public void run() {
try {
while (!Thread.currentThread().isInterrupted()) {
System.out.println("Le thread s'exécute...");
Thread.sleep(1000);
}
} catch (InterruptedException e) {
System.out.println("Le thread a été interrompu pendant le sommeil");
}
System.out.println("Le thread a terminé.");
}

public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(new Exemple Interruption());
thread.start();
Thread.sleep(5000); // Laisser le thread s'exécuter pendant 5 secondes
thread.interrupt();
}
}

Dans cet exemple, le thread s'exécute jusqu'à ce qu'il soit interrompu après 5 secondes.

6. isAlive()

La méthode isAlive() est comme vérifier si quelqu'un est toujours à son bureau. Elle renvoie true si le thread est toujours en cours d'exécution. Voici un exemple rapide :

public class ExempleVivant extends Thread {
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Le thread s'exécute : " + i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

public static void main(String[] args) throws InterruptedException {
ExempleVivant thread = new ExempleVivant();
thread.start();

while (thread.isAlive()) {
System.out.println("Le thread principal attendra jusqu'à ce que MonThread soit vivant");
Thread.sleep(1500);
}
System.out.println("Le thread principal est exécuté jusqu'à la fin");
}
}

Cet exemple montre le thread principal en attente et vérifiant si notre thread personnalisé est toujours vivant.

Conclusion

Et voilà, amis ! Nous avons fait le tour du domaine du contrôle des threads en Java, explorant chaque méthode comme des aventuriers dans un nouveau monde. Souvenez-vous, comme apprendre à cuisiner, maîtriser le contrôle des threads nécessite de la pratique. N'ayez pas peur d'expérimenter avec ces méthodes dans votre propre code.

En conclusion, je me souviens d'un étudiant qui m'a dit qu'il a finally compris les threads lorsqu'il les a imaginés comme différents cuisiniers dans une cuisine, tous travaillant ensemble pour créer un repas. Trouvez votre propre analogie qui fonctionne pour vous !

Continuez à coder, continuez à apprendre, et surtout, amusez-vous ! Qui sait ? La prochaine grande application multithreadée pourrait bien provenir d'un de vous. Jusqu'à la prochaine fois, peut-être que vos threads s'exécuteront en douceur et que votre code sera exempt de bugs !

Credits: Image by storyset