Commencer un nouveau fil en Java
-
Créer un thread en étendant la classe
Thread
en Java -
Créer un fil en implémentant l’interface
Runnable
en Java -
Créer un fil par l’objet
Thread
en Java - Créer un fil en utilisant la classe anonyme en Java
- Créer un thread à l’aide de la fonction lambda en Java
-
Créer un thread à l’aide de la classe
Executors
en Java
![Commencer un nouveau fil en Java](/img/Java/feature-image---start-new-thread-in-java.webp)
Ce tutoriel présente comment démarrer un nouveau thread en Java.
Un thread est la plus petite unité d’un programme/processus qui s’exécute en temps réel et maximise l’utilisation du processeur.
Java prend en charge le concept de thread et permet de créer un thread pour créer des applications multithread. Dans cet article, nous allons apprendre à créer un nouveau thread en Java.
Pour créer un nouveau thread en Java, on peut utiliser soit la classe Thread
soit l’interface Runnable
. Voyons quelques exemples.
Créer un thread en étendant la classe Thread
en Java
En Java, Thread
est une classe utilisée pour créer un nouveau thread et fournit plusieurs méthodes utilitaires. Dans cet exemple, nous avons utilisé la classe Thread
en l’étendant puis en commençant par utiliser la méthode start(). La méthode start()
démarre un nouveau thread. La méthode run()
est utilisée pour effectuer la tâche par le thread nouvellement créé. Le thread exécute automatiquement cette méthode. Voir l’exemple ci-dessous.
public class SimpleTesting extends Thread {
public static void main(String[] args) {
SimpleTesting st = new SimpleTesting();
st.start();
}
public void run() {
try {
System.out.println("New Thread Start");
Thread.sleep(1000);
System.out.println("Thread sleep for 1 second.");
} catch (InterruptedException e) {
System.out.println(e);
}
}
}
Production:
New Thread Start
Thread sleep for 1 second.
Créer un fil en implémentant l’interface Runnable
en Java
L’interface Runnable
peut être utilisée pour créer un nouveau thread, mais elle ne fournit pas les fonctionnalités fournies par la classe Thread. Cette interface fournit une méthode run()
qui peut être utilisée pour effectuer des tâches. Voir l’exemple ci-dessous.
public class SimpleTesting implements Runnable {
public static void main(String[] args) {
SimpleTesting st = new SimpleTesting();
Thread one = new Thread(st);
one.start();
}
public void run() {
try {
System.out.println("New Thread Start");
Thread.sleep(1000);
System.out.println("Thread sleep for 1 second.");
} catch (InterruptedException e) {
System.out.println(e);
}
}
}
Production:
New Thread Start
Thread sleep for 1 second.
Créer un fil par l’objet Thread
en Java
On peut directement créer un nouveau thread en utilisant l’objet Thread
et la méthode start()
, mais ce thread n’effectue aucune tâche puisque nous n’avons pas fourni l’implémentation de la méthode run()
. Nous pouvons obtenir des informations sur les threads en utilisant ses méthodes intégrées telles que getState()
, getName()
, etc. Voir l’exemple ci-dessous.
public class SimpleTesting {
public static void main(String[] args) {
Thread one = new Thread("New Thread");
System.out.println("Thread state : " + one.getState());
one.start();
System.out.println("Thread state : " + one.getState());
System.out.println("Thread Name : " + one.getName());
System.out.println("Thread state : " + one.getState());
}
}
Production:
Thread state : NEW
Thread state : RUNNABLE
Thread Name : New Thread
Thread state : TERMINATED
Créer un fil en utilisant la classe anonyme en Java
Ce n’est pas une nouvelle façon de créer un nouveau thread ; nous venons d’utiliser une classe anonyme en utilisant la classe Runnable
, l’avons passée au constructeur Thread
et avons démarré le thread. Voir l’exemple ci-dessous.
public class SimpleTesting {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
public void run() {
try {
System.out.println("New Thread Start");
Thread.sleep(1000);
System.out.println("Thread sleep for 1 second.");
} catch (InterruptedException e) {
System.out.println(e);
}
}
});
t1.start();
}
}
Production:
New Thread Start
Thread sleep for 1 second.
Créer un thread à l’aide de la fonction lambda en Java
La fonction Lambda a été ajoutée à la version Java 8 et peut être utilisée pour remplacer une classe anonyme dans Java. Ici, nous avons utilisé la fonction lambda pour créer un nouveau thread. Il s’agit d’un moyen compact et court de créer un fil. Voir l’exemple ci-dessous.
public class SimpleTesting {
public static void main(String[] args) throws InterruptedException {
new Thread(() -> {
try {
System.out.println("New Thread Start");
Thread.sleep(1000);
System.out.println("Thread sleep for 1 second.");
} catch (InterruptedException e) {
System.out.println(e);
}
}) {
{ start(); }
}.join();
}
}
Production:
New Thread Start
Thread sleep for 1 second.
Créer un thread à l’aide de la classe Executors
en Java
Les Executors
sont une classe appartenant au package de concurrence Java et peuvent être utilisées pour créer des applications multithreading. Nous pouvons donc l’utiliser pour créer un nouveau fil également. La méthode newSingleThreadExecutor()
initialise un nouveau thread puis est exécutée par la fonction submit()
. Voir l’exemple ci-dessous.
import java.util.concurrent.Executors;
public class SimpleTesting {
public static void main(String[] args) throws InterruptedException {
Executors.newSingleThreadExecutor().submit(() -> {
try {
System.out.println("New Thread Start");
Thread.sleep(1000);
System.out.println("Thread sleep for 1 second.");
} catch (InterruptedException e) {
System.out.println(e);
}
});
}
}
Production:
New Thread Start
Thread sleep for 1 second.