Un thread démon est un thread qui n'empêche pas la JVM de se fermer lorsque le programme est terminé mais que le thread est toujours en cours d'exécution. Un exemple de thread de démon est le garbage collection.
Vous pouvez utiliser la méthode setDaemon(boolean) pour modifier les propriétés du démon Thread avant le démarrage du thread.
Quelques points supplémentaires (Référence: Java Concurrency in Practice )
- Lorsqu'un nouveau thread est créé, il hérite du statut de démon de son parent.
Lorsque tous les threads autres que les démons sont terminés, la machine virtuelle Java s'arrête et tous les threads restants sont abandonnés :
- enfin les blocs ne sont pas exécutés ,
- les piles ne sont pas déroulées - la JVM se ferme.
Pour cette raison, les threads de démon doivent être utilisés avec parcimonie et il est dangereux de les utiliser pour des tâches susceptibles d'exécuter toute sorte d'E/S.
Toutes les réponses ci-dessus sont bonnes. Voici un petit extrait de code simple, pour illustrer la différence. Essayez-le avec chacune des valeurs true et false dans setDaemon.
public class DaemonTest {
public static void main(String[] args) {
new WorkerThread().start();
try {
Thread.sleep(7500);
} catch (InterruptedException e) {
// handle here exception
}
System.out.println("Main Thread ending") ;
}
}
class WorkerThread extends Thread {
public WorkerThread() {
// When false, (i.e. when it's a user thread),
// the Worker thread continues to run.
// When true, (i.e. when it's a daemon thread),
// the Worker thread terminates when the main
// thread terminates.
setDaemon(true);
}
public void run() {
int count = 0;
while (true) {
System.out.println("Hello from Worker "+count++);
try {
sleep(5000);
} catch (InterruptedException e) {
// handle exception here
}
}
}
}
Traditionnellement, les processus démons sous UNIX étaient ceux qui fonctionnaient en permanence en arrière-plan, un peu comme les services sous Windows.
Un thread démon dans Java n'empêche pas la machine virtuelle Java de quitter. Plus précisément, la machine virtuelle Java se fermera s'il ne reste que des threads de démon. Vous en créez un en appelant la méthode setDaemon() sur Thread.
Ayez une lecture de threads Daemon .
Les threads de démon ressemblent à des fournisseurs de services pour d'autres threads ou objets s'exécutant dans le même processus que le thread de démon. Les threads de démon sont utilisés pour les tâches de support en arrière-plan et ne sont nécessaires que pendant l'exécution des threads normaux. Si les threads normaux ne sont pas en cours d'exécution et que les threads restants sont des threads de démon, l'interpréteur s'arrête.
Par exemple, le navigateur HotJava utilise jusqu'à quatre threads démon nommés "Image Fetcher" pour extraire des images du système de fichiers ou du réseau pour tout thread qui en a besoin.
Les threads de démon sont généralement utilisés pour effectuer des services pour votre application/applet (comme le chargement des "bits de fiddley"). La principale différence entre les threads utilisateur et les démons est que la JVM ne ferme un programme que lorsque tous les threads utilisateur sont terminés. La JVM termine les threads de démon lorsqu'il n'y a plus de threads utilisateur en cours d'exécution, y compris le thread principal d'exécution.
setDaemon (true/false)? Cette méthode est utilisée pour spécifier qu'un thread est un thread démon.
public boolean isDaemon ()? Cette méthode est utilisée pour déterminer si le thread est un thread démon ou non.
Par exemple:
public class DaemonThread extends Thread {
public void run() {
System.out.println("Entering run method");
try {
System.out.println("In run Method: currentThread() is" + Thread.currentThread());
while (true) {
try {
Thread.sleep(500);
} catch (InterruptedException x) {}
System.out.println("In run method: woke up again");
}
} finally {
System.out.println("Leaving run Method");
}
}
public static void main(String[] args) {
System.out.println("Entering main Method");
DaemonThread t = new DaemonThread();
t.setDaemon(true);
t.start();
try {
Thread.sleep(3000);
} catch (InterruptedException x) {}
System.out.println("Leaving main method");
}
}
Sortie:
C:\Java\thread>javac DaemonThread.Java
C:\Java\thread>Java DaemonThread
Entering main Method
Entering run method
In run Method: currentThread() isThread[Thread-0,5,main]
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
In run method: woke up again
Leaving main method
C:\j2se6\thread>
Définition de démon (informatique):
Un processus d'arrière-plan qui traite les demandes de services tels que le spoulage d'impression et les transferts de fichiers, et est en sommeil lorsqu'il n'est pas requis.
—— Source: Anglais selon les dictionnaires Oxford
Qu'est-ce qu'un fil Daemon en Java?
- Les threads de démon peuvent être arrêtés à tout moment entre leur flux, le thread utilisateur non-Daemon, par exemple, s'exécute complètement.
- Les threads de démon s'exécutent avec une priorité basse.
- Les threads de démon sont des threads qui s'exécutent de manière intermittente en arrière-plan tant que d'autres threads autres que des démons sont en cours d'exécution.
- Lorsque tous les threads non-démon sont terminés, les threads de démon se terminent automatiquement.
- Les threads démon sont des fournisseurs de services pour les threads utilisateur exécutés dans le même processus.
- La JVM ne se soucie pas des threads de démon à terminer quand elle est en cours d’exécution, pas même le blocage final laisse également s’exécuter. JVM donne la préférence aux threads non-démon créés par nous.
- Les threads Daemon agissent comme des services dans Windows.
- La machine virtuelle Java arrête les threads de démon lorsque tous les threads utilisateur (contrairement aux threads de démon) sont terminés. Par conséquent, les threads de démon peuvent être utilisés pour implémenter, par exemple, une fonctionnalité de surveillance car le thread est arrêté par la machine virtuelle Java dès que tous les threads utilisateur se sont arrêtés.
Un fil de démon est un fil qui est considéré comme effectuant certaines tâches en arrière-plan, comme la gestion de demandes ou de diverses tâches chronologiques pouvant exister dans une application.
Lorsque votre programme n'a plus que threads de démon, il se ferme. En effet, ces threads fonctionnent généralement avec des threads normaux et permettent la gestion en arrière-plan des événements.
Vous pouvez spécifier qu'un Thread est un démon en utilisant la méthode setDaemon, ils ne sortent généralement pas, ni ils sont interrompus .. ils s'arrêtent simplement lorsque l'application s'arrête.
Une idée fausse que je voudrais clarifier:
- Supposons que si le fil démon (par exemple B) est créé dans le fil utilisateur (par exemple A); la fin de ce thread utilisateur/thread parent (A) ne mettra pas fin au thread de démon/thread enfant (B) qu'il a créé; le thread utilisateur fourni est le seul en cours d'exécution.
- Il n'y a donc pas de relation parent-enfant à la fin du thread. Tous les threads démons (quel que soit l'endroit où ils ont été créés) se termineront s'il n'y a plus de thread utilisateur actif et que la JVM se termine.
- Même cela est vrai pour les deux (parent/enfant) sont des threads de démon.
- Si un thread enfant créé à partir d'un thread de démon, il s'agit également d'un thread de démon. Cela n'aura pas besoin d'un paramètre d'indicateur de thread de démon explicite. De la même manière, si un thread enfant est créé à partir d'un thread utilisateur, il s'agit également d'un thread utilisateur. Si vous souhaitez le modifier, un paramètre d'indicateur de démon explicite est nécessaire avant le démarrage de ce thread enfant.
Fil de discussion Daemon et Threads utilisateur. En général, tous les threads créés par le programmeur sont des utilisateurs (sauf si vous le spécifiez comme démon ou si votre thread parent est un démon). Les threads utilisateur sont généralement destinés à exécuter notre code de programme. La machine virtuelle Java ne se termine que si tous les threads utilisateur se terminent.
Java a un type de fil spécial appelé daemon thread.
- Très faible priorité.
- S'exécute uniquement lorsqu'aucun autre thread du même programme n'est en cours d'exécution.
- JVM termine le programme en terminant ces threads, lorsque les threads de démon sont les seuls threads exécutés dans un programme.
A quoi servent les fils de démon?
Normalement utilisé comme fournisseur de services pour les threads normaux. Ayez généralement une boucle infinie qui attend la demande de service ou effectue les tâches du thread. Ils ne peuvent pas faire de travail important. (Parce que nous ne savons pas quand ils auront du temps processeur et ils peuvent terminer à tout moment s'il n'y a pas d'autres threads en cours d'exécution.)
Un exemple typique de ce type de thread est le récupérateur de déchets Java .
Il y a plus...
- Vous appelez uniquement la méthode
setDaemon()avant d'appeler la méthodestart(). Une fois que le thread est en cours d’exécution, vous ne pouvez plus modifier son statut de démon. - Utilisez la méthode
isDaemon()pour vérifier si un thread est un thread démon ou un thread utilisateur.
Les fils de démon sont comme des assistants. Les threads non-Daemon ressemblent aux interprètes de premier plan. Les assistants aident les interprètes à terminer un travail. Lorsque le travail est terminé, les interprètes n'ont plus besoin d'aide pour effectuer leurs tâches. Comme aucune aide n'est nécessaire, les assistants quittent les lieux. Ainsi, lorsque les tâches des threads non-Daemon sont terminées, les threads Daemon s'en vont.
Le thread démon ressemble à un thread normal, sauf que la machine virtuelle Java ne s'arrêtera que lorsque les autres threads non démon n'existent pas. Les threads de démon sont généralement utilisés pour effectuer des services pour votre application.
Les threads daemon dans Java sont les threads qui s'exécutent en arrière-plan et sont principalement créés par JVM pour effectuer des tâches en arrière-plan telles que le ramassage des ordures et d'autres tâches de gestion interne.
Points à noter:
Tout fil créé par le fil principal et exécutant la méthode principale dans Java est par défaut un non démon, car Thread hérite de sa nature de démon du Thread qui le crée, c’est-à-dire le thread parent et, puisque le fil principal est un thread non démon, les autres threads créés à partir de celui-ci resteront non-démons jusqu'à ce qu'ils soient explicitement créés en appelant setDaemon (true).
Thread.setDaemon (true) crée un démon Thread, mais celui-ci ne peut être appelé qu'après le démarrage de Thread en Java. IllegalThreadStateException lève une exception si le thread correspondant est déjà démarré et en cours d'exécution.
Différence entre les threads Daemon et Non Daemon dans Java:
1) La JVM n'attend pas qu'un thread de démon se termine avant d'exister.
2) Les threads de démon sont traités différemment des threads utilisateur lorsque la machine virtuelle Java se termine, enfin, les blocs ne sont pas appelés, les piles ne sont pas non blessées et la machine virtuelle Java quitte.
Les threads de démon sont généralement appelés threads "Fournisseur de services". Ces threads ne doivent pas être utilisés pour exécuter du code de programme mais du code système. Ces threads sont parallèles à votre code mais JVM peut les tuer à tout moment. Lorsque la machine virtuelle Java ne détecte aucun thread utilisateur, elle l’arrête et tous les threads démons se terminent instantanément. Nous pouvons définir un thread non-démon sur démon en utilisant:
setDaemon(true)
Voici un exemple pour tester le comportement des threads de démon en cas d'exit de jvm en raison de l'absence de threads d'utilisateur.
Veuillez noter la deuxième dernière ligne dans la sortie ci-dessous. Lorsque le thread principal est sorti, le thread du démon est également mort et n’a pas imprimé l’instruction finalement exécutée9 dans le bloc finally. Cela signifie que toutes les ressources d'E/S fermées dans le bloc finally d'un thread de démon ne seront pas fermées si la machine virtuelle Java quitte, en raison de la non-existence de threads utilisateur.
public class DeamonTreadExample {
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(() -> {
int count = 0;
while (true) {
count++;
try {
System.out.println("inside try"+ count);
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
System.out.println("finally executed"+ count);
}
}
});
t.setDaemon(true);
t.start();
Thread.currentThread().sleep(10000);
System.out.println("main thread exited");
}
}
Sortie
inside try1
finally executed1
inside try2
finally executed2
inside try3
finally executed3
inside try4
finally executed4
inside try5
finally executed5
inside try6
finally executed6
inside try7
finally executed7
inside try8
finally executed8
inside try9
finally executed9
inside try10
main thread exited
En Java, Daemon Threads sont l'un des types de thread qui n'empêchent pas Java Machine virtuelle (JVM) de quitter. L'objectif principal d'un thread de démon est d'exécuter une tâche en arrière-plan, en particulier dans le cas d'une tâche ou d'un travail périodique de routine. Avec les exits JVM, le thread de démon meurt également.
En définissant une thread.setDaemon(true), un thread devient un thread de démon. Cependant, vous ne pouvez définir cette valeur qu'au démarrage du thread.
Le thread démon est comme un processus démon qui est responsable de la gestion des ressources, un thread démon est créé par le Java VM pour servir les threads utilisateur. Exemple de système de mise à jour pour Unix, Unix est un processus démon. l'enfant du fil démon est toujours un fil démon, donc le démon par défaut est false. vous pouvez vérifier le fil en tant que démon ou utilisateur à l'aide de la méthode "isDaemon ()". donc les processus ou processus démons sont essentiellement responsables de la gestion des ressources. Par exemple, lorsque vous démarrez JVM, un ramasse-miettes est en cours d'exécution, c'est-à-dire un thread démon dont la priorité est 1, c'est-à-dire la gestion de la mémoire. jvm est en vie tant que le thread utilisateur est en vie, vous ne pouvez pas tuer le démon thread.jvm est responsable de tuer les threads du démon.
Les threads de démon sont, comme tout le monde l’a expliqué, ne contraindront pas la machine virtuelle Java à quitter. C’est donc un thread intéressant pour Application du point de vue de la sortie.
Vous souhaitez ajouter que les threads démons peuvent être utilisés lorsque, par exemple, je fournis une API, telle que le transfert de données vers un serveur tiers ou un serveur JMS, il peut être nécessaire d'agréger des données au niveau de la JVM client, puis de les envoyer à un thread distinct. Je peux créer ce fil en tant que thread démon, s'il ne s'agit pas d'une donnée obligatoire à transmettre au serveur. Ce type de données s'apparente à log push/agrégation.
Cordialement, Manish
Les threads de démon sont des threads qui s'exécutent en arrière-plan tant que d'autres threads non démon du processus sont toujours en cours d'exécution. Ainsi, lorsque tous les threads non-démon sont terminés, ils sont terminés. Un exemple pour le thread non-démon est le thread qui exécute le Main. Un thread est créé en appelant la méthode setDaemon() avant le démarrage du thread
Pour plus de références: thread de démon en Java
Pour moi, le fil d'un démon est comme le gardien de la maison pour les fils de l'utilisateur. Si tous les threads utilisateur sont terminés, le thread de démon n'a pas de travail et est tué par JVM. Je l'ai expliqué dans le vidéo YouTube .
Parlons seulement en code avec des exemples de travail. J'aime la réponse de Russ ci-dessus, mais pour dissiper tout doute que j'avais, je l'ai un peu amélioré. Je l'ai exécuté deux fois, une fois avec le thread de travail défini sur deamon true (thread de deamon) et une autre fois, sur false (thread d'utilisateur). Il confirme que le thread de démon se termine lorsque le thread principal se termine.
public class DeamonThreadTest {
public static void main(String[] args) {
new WorkerThread(false).start(); //set it to true and false and run twice.
try {
Thread.sleep(7500);
} catch (InterruptedException e) {
// handle here exception
}
System.out.println("Main Thread ending");
}
}
class WorkerThread extends Thread {
boolean isDeamon;
public WorkerThread(boolean isDeamon) {
// When false, (i.e. when it's a user thread),
// the Worker thread continues to run.
// When true, (i.e. when it's a daemon thread),
// the Worker thread terminates when the main
// thread terminates.
this.isDeamon = isDeamon;
setDaemon(isDeamon);
}
public void run() {
System.out.println("I am a " + (isDeamon ? "Deamon Thread" : "User Thread (none-deamon)"));
int counter = 0;
while (counter < 10) {
counter++;
System.out.println("\tworking from Worker thread " + counter++);
try {
sleep(5000);
} catch (InterruptedException e) {
// handle exception here
}
}
System.out.println("\tWorker thread ends. ");
}
}
result when setDeamon(true)
=====================================
I am a Deamon Thread
working from Worker thread 0
working from Worker thread 1
Main Thread ending
Process finished with exit code 0
result when setDeamon(false)
=====================================
I am a User Thread (none-deamon)
working from Worker thread 0
working from Worker thread 1
Main Thread ending
working from Worker thread 2
working from Worker thread 3
working from Worker thread 4
working from Worker thread 5
working from Worker thread 6
working from Worker thread 7
working from Worker thread 8
working from Worker thread 9
Worker thread ends.
Process finished with exit code 0
JVM accomplira le travail à la fin de la dernière exécution d'un thread non démon. Par défaut, JVM crée un thread en tant que nondaemon, mais nous pouvons créer Thread en tant que démon à l'aide de la méthode setDaemon(true). Un bon exemple de thread Daemon est le thread GC qui termine son travail dès que tous les threads nondaemon sont terminés.
Les threads démon meurent lorsque le thread créateur se ferme.
Les threads non démon (par défaut) peuvent même vivre plus longtemps que le thread principal.
if ( threadShouldDieOnApplicationEnd ) {
thread.setDaemon ( true );
}
thread.start();