Java - Démarrer un Thread

Salut à toi, futurs magiciens Java ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde du threading Java. Ne t'inquiète pas si tu es nouveau dans la programmation ; je serai ton guide amical à travers cette aventure. C'est parti !

Qu'est-ce qu'un Thread ?

Avant de commencer à créer des threads, comprenons ce qu'ils sont. Imagine que tu es dans une cuisine, en train de préparer un repas complexe. Tu coupes des légumes, tu remues une casserole et tu vérifies le four, tout en même temps. Chacune de ces tâches est comme un thread dans la programmation. Ce sont des parties différentes d'un programme qui s'exécutent simultanément.

Pourquoi utiliser des Threads ?

Les threads sont super utiles ! Ils aident nos programmes à faire plusieurs choses à la fois, les rendant plus rapides et plus efficaces. C'est comme avoir plusieurs cuisiniers dans la cuisine au lieu d'un seul.

Démarrer un Thread en Java

En Java, nous avons deux principales méthodes pour créer et démarrer un thread. Explorons les toutes deux !

1. Implémenter l'Interface Runnable

Cela est souvent considéré comme la meilleure façon de créer un thread. Voici comment on fait :

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

public class Main {
public static void main(String[] args) {
MonRunnable monRunnable = new MonRunnable();
Thread thread = new Thread(monRunnable);
thread.start();
}
}

Reprenons cela :

1. Nous créons une classe MonRunnable qui implémente l'interface Runnable.
2. Nous définissons ce que le thread doit faire dans la méthode run().
3. Dans notre méthode main, nous créons une instance de MonRunnable.
4. Nous créons un objet Thread, en passant notre instance MonRunnable à celui-ci.
5. Nous appelons la méthode start() pour commencer l'exécution du thread.

2. Étendre la Classe Thread

Une autre façon de créer un thread est en étendant la classe Thread :

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

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

Voici ce qui se passe :

1. Nous créons une classe MonThread qui étend la classe Thread.
2. Nous surchargeons la méthode run() pour définir ce que le thread doit faire.
3. Dans notre méthode main, nous créons une instance de MonThread.
4. Nous appelons la méthode start() pour commencer l'exécution du thread.

La Méthode sleep()

Parfois, nous voulons que notre thread fasse une petite sieste. C'est là que la méthode sleep() devient pratique. C'est comme dire à notre cuisinier de faire une courte pause avant de continuer à cuisiner.

Voici un exemple :

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

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

Dans cet exemple :

1. Notre thread imprime un message cinq fois.
2. Entre chaque impression, il dort pendant 1000 millisecondes (1 seconde).
3. Nous utilisons un bloc try-catch parce que sleep() pourrait lancer une InterruptedException.

Méthodes Communes de Thread

Voici un tableau de certaines méthodes courantes de thread que vous pourriez trouver utiles :

Méthode	Description
start()	Commence l'exécution du thread
run()	Contient le code qui définit ce que fait le thread
sleep(long millis)	Fait pause le thread pendant un nombre spécifié de millisecondes
join()	Attends que le thread meurt
isAlive()	Teste si le thread est vivant
getName()	Retourne le nom du thread
setName(String name)	Change le nom du thread
getPriority()	Retourne la priorité du thread
setPriority(int priority)	Change la priorité du thread

Un Exemple du Monde Réel

Mettons tout cela ensemble avec un exemple fun. Imagine que nous exploitons une pizzeria, et que nous voulons simuler la fabrication de plusieurs pizzas à la fois :

public class FaiseurDePizza implements Runnable {
private String nomPizza;

public FaiseurDePizza(String nom) {
this.nomPizza = nom;
}

public void run() {
System.out.println("Commencer à faire " + nomPizza);
try {
Thread.sleep(2000);  // Simuler le temps de fabrication de la pizza
System.out.println(nomPizza + " est prête !");
} catch (InterruptedException e) {
System.out.println("La fabrication de la pizza a été interrompue !");
}
}
}

public class Pizzeria {
public static void main(String[] args) {
Thread margherita = new Thread(new FaiseurDePizza("Margherita"));
Thread pepperoni = new Thread(new FaiseurDePizza("Pepperoni"));
Thread vegetarien = new Thread(new FaiseurDePizza("Veggie Supreme"));

margherita.start();
pepperoni.start();
vegetarien.start();
}
}

Dans cet exemple, nous simulons la fabrication de trois pizzas simultanément. Chaque pizza est un thread distinct, et elles toutes "cuisent" en même temps.

Conclusion

Félicitations ! Vous avez appena fait vos premiers pas dans le monde du threading Java. Souvenez-vous, comme apprendre à cuisiner, maîtriser les threads nécessite de la pratique. N'ayez pas peur d'expérimenter et d'essayer de créer vos propres programmes multithreadés.

En continuant votre voyage Java, vous découvrirez encore plus de fonctionnalités passionnantes des threads, comme la synchronisation et la communication entre threads. Mais pour l'instant, félicitez-vous - vous n'êtes plus un débutant en threading !

Continuez à coder, continuez à apprendre, et surtout, amusez-vous ! Qui sait ? Peut-être que votre prochain projet sera une œuvre multithreadée qui révolutionnera le monde de la programmation Java. Rêvez grand, codez plus grand !

Credits: Image by storyset