Fils Java
Fils Java
Les threads permettent à un programme de fonctionner plus efficacement en faisant plusieurs choses en même temps.
Les threads peuvent être utilisés pour effectuer des tâches complexes en arrière-plan sans interrompre le programme principal.
Création d'un fil
Il existe deux façons de créer un fil.
Il peut être créé en étendant la Threadclasse et en remplaçant sa run()
méthode :
Étendre la syntaxe
public class Main extends Thread { public void run() { System.out.println("This code is running in a thread");}}
Une autre façon de créer un thread consiste à implémenter l' Runnableinterface :
Implémenter la syntaxe
public class Main implements Runnable {
public void run() {
System.out.println("This code is running in a thread");
}
}Exécution de threads
Si la classe étend la Threadclasse, le thread peut être exécuté en créant une instance de la classe et en appelant sa start()méthode :
Étendre l'exemple
public class Main extends Thread {
public static void main(String[] args) {
Main thread = new Main();
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}
Si la classe implémente l' Runnableinterface, le thread peut être exécuté en passant une instance de la classe au Threadconstructeur d'un objet, puis en appelant la
start()méthode du thread :
Exemple d'implémentation
public class Main implements Runnable {
public static void main(String[] args) {
Main obj = new Main();
Thread thread = new Thread(obj);
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}
Différences entre "étendre" et "implémenter" les threads
La principale différence est que lorsqu'une classe étend la classe Thread, vous ne pouvez étendre aucune autre classe, mais en implémentant l'interface Runnable, il est également possible d'étendre une autre classe, comme : class MyClass extends OtherClass implements Runnable.
Problèmes de simultanéité
Étant donné que les threads s'exécutent en même temps que d'autres parties du programme, il n'y a aucun moyen de savoir dans quel ordre le code s'exécutera. Lorsque les threads et le programme principal lisent et écrivent les mêmes variables, les valeurs sont imprévisibles. Les problèmes qui en résultent sont appelés problèmes de concurrence.
Exemple
Un exemple de code où la valeur du montant variable est imprévisible :
public class Main extends Thread { public static int amount = 0; public static void main(String[] args) { Main thread = new Main(); thread.start(); System.out.println(amount); amount++; System.out.println(amount);}public void run() { amount++;}}
Pour éviter les problèmes de concurrence, il est préférable de partager le moins d'attributs possible entre les threads. Si les attributs doivent être partagés, une solution possible consiste à utiliser la isAlive()
méthode du thread pour vérifier si le thread a fini de s'exécuter avant d'utiliser les attributs que le thread peut modifier.
Exemple
Utilisez isAlive()pour éviter les problèmes de simultanéité :
public class Main extends Thread { public static int amount = 0; public static void main(String[] args) { Main thread = new Main(); thread.start(); // Wait for the thread to finish while(thread.isAlive()) { System.out.println("Waiting...");}// Update amount and print its value System.out.println("Main: " + amount); amount++; System.out.println("Main: " + amount);}public void run() { amount++;}}