Qu'est-ce qu'un thread démon en Java?

809

Quelqu'un peut-il me dire quels sont les threads démon en Java ?

bascule
la source
20
Le Threadjavadoc décrit ce qu'ils sont: java.sun.com/javase/6/docs/api/java/lang/Thread.html
skaffman
2
Pour les threads démon, lorsque la JVM s'arrête, tous les threads démon sont fermés Pour cette raison, les threads démon ne doivent pas être utilisés souvent car le nettoyage peut ne pas être exécuté sur eux. Par exemple, aucune E / S ne quitterait normalement et n'écrirait / lisait jusqu'à la fin.
msj121

Réponses:

631

Un thread démon est un thread qui n'empêche pas la sortie de la JVM à la fin du programme mais le thread est toujours en cours d'exécution. Un exemple de thread démon est le garbage collection.

Vous pouvez utiliser la setDaemon(boolean)méthode pour modifier les Threadpropriétés du démon avant le démarrage du thread.

b_erb
la source
210
Pour la postérité, setDamon(boolean)ne peut être appelé qu'après le démarrage du thread. Par défaut, le thread hérite de l'état du démon de son thread parent.
Gray
1
"n'empêche pas la JVM de se terminer à la fin du programme mais le thread est toujours en cours d'exécution" tandis que @sateesh dit que "JVM arrête tous les threads démon restants sont abandonnés". Les threads démon finissent-ils donc de s'exécuter à la fermeture de la JVM?
Gerald
23
@Gerald, TOUS les threads sont supprimés à la fermeture de la JVM. B_erb a dit: "... quand le programme se termine." Cela signifie que si le programme ne tue pas explicitement la JVM, la JVM se tuera automatiquement à la fin du dernier thread non démon. Les threads normaux définissent «à la fin du programme». Les threads démons ne le font pas.
Solomon Slow
2
Donc, cette ligne thread that does not prevent the JVM from exiting when the program finishes but the thread is still runningsignifie essentiellement que le processus JVM qui a démarré le thread ne se soucie pas de savoir si le thread démon a terminé son exécution ou non, il se terminera lui-même si tous les threads normaux ont terminé l'exécution.
Bhargav
1
@SolomonSlow Quelles sont les conséquences de la suppression d'un thread démon (par exemple, un garbage collector) alors qu'il fait encore son travail, à la fin de la JVM? Merci.
Venkat Ramakrishnan
340

Quelques points supplémentaires (Référence: Java Concurrency in Practice )

  • Lorsqu'un nouveau thread est créé, il hérite du statut démon de son parent.
  • Une fois tous les threads non démon terminés, la JVM s'arrête et tous les threads démon restants sont abandonnés :

    • enfin les blocs ne sont pas exécutés ,
    • les piles ne sont pas déroulées - la JVM sort juste.

    Pour cette raison, les threads démon doivent être utilisés avec parcimonie, et il est dangereux de les utiliser pour des tâches qui pourraient effectuer n'importe quel type d'E / S.

sateesh
la source
3
Pourquoi les threads démon ne devraient-ils pas être utilisés pour les E / S? Est-ce une préoccupation à propos de BufferedWriters, etc.
Paul Cager
4
@PaulCager Oui, ils peuvent aussi se faire couper les genoux au milieu d'une écriture / lecture.
Cruncher
52
Le deuxième point est un non-sens. Lorsque la JVM s'arrête, tous les threads meurent et aucun finallybloc n'est exécuté, que les threads soient des démons ou non. N'appelez donc pas System.exit(…)si vous pensez qu'il peut y avoir des threads en cours d'exécution d'E / S. La seule différence est que la JVM déclenchera sa propre terminaison lorsqu'il ne restera que des threads démon.
Holger
11
Qu'entend-on par «les piles ne sont pas déroulées»?
ɢʜʘʂʈ ʀɛɔʘɴ
2
@ ɢʜʘʂʈʀɛɔʘɴ il y a quelques explications sur les "piles de déroulement", y compris celle-ci: flylib.com/books/en/2.254.1.277/1
user766353
175

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 in 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
            }
        }
    }
}
russ
la source
2
@russ Bon extrait de code! J'ai dû définir la classe WorkerThread comme statique cependant.
2013 à 20h13
@xli vous auriez pu faire de nouveaux DaemonTest (). new WorkerThread (). start () aussi :)
abhy
@russ bon exemple. Je savais que la valeur par défaut est "setDeamon (false)" si vous ne définissez pas explicitement "setDaemon (true)"
huseyin
96

Traditionnellement, les processus démon sous UNIX étaient ceux qui fonctionnaient constamment en arrière-plan, un peu comme les services sous Windows.

Un thread démon en Java n'empêche pas la sortie de la JVM. Plus précisément, la JVM se fermera lorsqu'il ne restera que des threads démon. Vous en créez un en appelant la setDaemon()méthode Thread.

Lisez les fils de discussion de Daemon .

cletus
la source
3
votre lien est mort à ce moment, peut-être voulez-vous le mettre à jour? de toute façon, +1 pour vous.
Jasonw
2
J'aime la comparaison entre UNIX et Windows.
Premraj
Meilleure explication ici!
LoveMeow
57

Les threads démon sont comme des fournisseurs de services pour d'autres threads ou objets s'exécutant dans le même processus que le thread démon. Les threads 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 démon, l'interpréteur se ferme.

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 démon sont généralement utilisés pour effectuer des services pour votre application / applet (comme le chargement des "bits fiddley"). La principale différence entre les threads utilisateur et les threads démon est que la machine virtuelle Java ferme uniquement un programme lorsque tous les threads utilisateur sont terminés. Les threads démon sont arrêtés par la JVM lorsqu'il n'y a plus de threads utilisateur en cours d'exécution, y compris le thread principal d'exécution.

setDaemon (vrai / faux)? Cette méthode est utilisée pour spécifier qu'un thread est un thread démon.

public booléen 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");
    }

}

Production:

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>
Okky
la source
37

Définition de démon (informatique):

Un processus d'arrière-plan qui gère les demandes de services tels que la mise en file d'attente d'impression et les transferts de fichiers, et est inactif lorsqu'il n'est pas nécessaire.

—— Source: anglais par Oxford Dictionaries

Qu'est-ce que le thread Daemon en Java?

  • Les threads démons peuvent s'arrêter à tout moment entre leurs flux, Non-Daemon c'est-à-dire que le thread utilisateur s'exécute complètement.
  • Les threads démon sont des threads qui s'exécutent par intermittence en arrière-plan tant que d'autres threads non démon sont en cours d'exécution.
  • Lorsque tous les threads non démon sont terminés, les threads démon se terminent automatiquement.
  • Les threads démon sont des fournisseurs de services pour les threads utilisateur s'exécutant dans le même processus.
  • La JVM ne se soucie pas des threads du démon à terminer lorsqu'elle est en cours d'exécution, même pas finalement bloquer également laisser s'exécuter. JVM donne la préférence aux threads non démons créés par nos soins.
  • Les threads démon font office de services dans Windows.
  • La machine virtuelle Java arrête les threads démon lorsque tous les threads utilisateur (contrairement aux threads démon) sont terminés. Par conséquent, les threads démon peuvent être utilisés pour implémenter, par exemple, une fonctionnalité de surveillance car le thread est arrêté par la JVM dès que tous les threads utilisateur se sont arrêtés.
Premraj
la source
si vous appelez System.exit (), aucun bloc finalement n'est exécuté, quel que soit le thread étant un thread démon. en effet, enfin, les blocs sont exécutés dans les threads démon même après la fin du dernier thread utilisateur si la JVM n'a pas encore tué le thread
benez
5
Un thread démon s'exécute avec la même priorité que son thread de création, sauf s'il a été modifié avant de démarrer. Les threads démons ne sont pas nécessairement des `` fournisseurs de services '' ou des services Windows ou autre chose indiqué ici: ce ne sont que des threads qui n'empêchent pas la JVM de se fermer. Période.
Marquis de Lorne
35

Un thread démon est un thread qui est considéré comme effectuant certaines tâches en arrière-plan comme la gestion des demandes ou divers chronjobs pouvant exister dans une application.

Lorsque votre programme n'a plus que des threads démon, il se fermera. En effet, ces threads fonctionnent généralement avec les threads normaux et fournissent une gestion en arrière-plan des événements.

Vous pouvez spécifier que a Threadest un démon en utilisant une setDaemonméthode, ils ne quittent généralement pas, ils ne sont pas interrompus .. ils s'arrêtent juste quand l'application s'arrête.

Jack
la source
1
C'est parce que c'est un thread démon, et c'est le sens de «démon». Votre raisonnement est à l'envers.
Marquis de Lorne
15

Je voudrais clarifier une idée fausse:

  • Supposons que si le thread démon (disons B) est créé dans le thread utilisateur (disons A); la fin de ce thread utilisateur / thread parent (A) ne mettra pas fin au thread 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émon (quel que soit l'endroit où ils sont créés) se termineront dès qu'il n'y aura pas de thread utilisateur direct unique et cela entraînera l'arrêt de la JVM.
  • Même cela est vrai pour les deux (parent / enfant) sont des threads démon.
  • Si un thread enfant créé à partir d'un thread démon, il s'agit également d'un thread démon. Cela ne nécessite aucun paramètre d'indicateur de thread de démon explicite. De même, si un thread enfant créé à partir d'un thread utilisateur est également 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.
Kanagavelu Sugumar
la source
Ce n'est pas cité de quoi que ce soit. N'utilisez pas la mise en forme des guillemets pour le texte qui n'est pas cité. Le premier paragraphe de la «citation» est incorrect et contredit le second.
Marquis de Lorne
@EJP GOT IT, donc chacun doit donner des citations à d'autres personnes ici, pas les leurs. OU nous-mêmes avons une citation quelque part puis pointez ici?
Kanagavelu Sugumar
Oui, si vous citez quelqu'un, vous devez le citer, comme partout ailleurs, mais si vous n'avez cité personne, ne le formatez pas comme si vous l'aviez fait. Je ne peux pas faire la tête ou la queue de ta deuxième phrase.
Marquis de Lorne
12

Thread démon et Threads utilisateur. Généralement, tous les threads créés par le programmeur sont des threads utilisateur (sauf si vous spécifiez qu'il s'agit d'un démon ou que votre thread parent est un thread démon). Les threads utilisateur sont généralement destinés à exécuter notre code de programme. JVM ne se termine que si tous les threads utilisateur se terminent.

soubhagini
la source
10

Java a un type spécial de thread appelé thread démon .

  • Priorité très faible.
  • 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 démon sont les seuls threads en cours d'exécution dans un programme.

À quoi servent les threads démon?

Normalement utilisé comme fournisseur de services pour les threads normaux. Ont généralement une boucle infinie qui attend la demande de service ou exécute les tâches du thread. Ils ne peuvent pas faire des travaux importants. (Parce que nous ne savons pas quand ils auront du temps CPU 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 threads est le garbage collector Java .

Il y a plus...

  • Vous appelez uniquement la setDaemon()méthode avant d'appeler la start()méthode. Une fois le thread en cours d'exécution, vous ne pouvez pas modifier son état de démon.
  • Utilisez la isDaemon()méthode pour vérifier si un thread est un thread démon ou un thread utilisateur.
zxholy
la source
8
-1, je ne pense pas qu'un thread démon soit intrinsèquement de faible priorité. Certainement pas de documentation que j'ai vue sur de tels états. De plus, cette réponse SO prétend que la priorité et le démon sont orthogonaux: stackoverflow.com/a/10298353/839128
MikeFHay
5
Les threads démons n'ont rien à voir avec la priorité. Vous pouvez avoir un thread démon de haute priorité ou un thread non démon de faible priorité.
Gray
Un thread démon a initialement la même priorité que son thread de création.
Marquis de Lorne
L'instruction "'S'exécute uniquement lorsqu'aucun autre thread du même programme n'est en cours d'exécution" est trompeuse.
Fredrick Gauss
9

Les fils de démon sont comme des assistants. Les threads non Daemon sont comme les interprètes principaux. Les assistants aident les interprètes à terminer un travail. Une fois le travail terminé, les interprètes n'ont plus besoin d'aide pour jouer. Comme aucune aide n'est nécessaire, les assistants quittent le lieu. Ainsi, lorsque les travaux des threads non-démon sont terminés, les threads démon s'éloignent.

Harjit Singh
la source
5

Le thread démon est comme un thread normal, sauf que la JVM ne s'arrête que lorsque les autres threads non démon n'existent pas. Les threads démon sont généralement utilisés pour exécuter des services pour votre application.

Chanikag
la source
5

Les threads démon en 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 la récupération de place et d'autres tâches de gestion interne.

Points à noter:

  1. Tout thread créé par le thread principal, qui exécute la méthode principale en Java, est par défaut 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 thread principal est un thread non démon, tout autre thread créé à partir de celui-ci sera rester non-démon jusqu'à ce qu'il soit explicitement créé en appelant setDaemon (true).

  2. Thread.setDaemon (true) crée un démon Thread mais il ne peut être appelé qu'avant de démarrer Thread en Java. Il lèvera IllegalThreadStateException si le thread correspondant est déjà démarré et en cours d'exécution.

Différence entre le thread Daemon et Non Daemon en Java:

1) JVM n'attend aucun thread démon pour terminer avant d'exister.

2) Le thread démon est traité différemment du thread utilisateur lorsque la JVM se termine, enfin les blocs ne sont pas appelés, les piles ne sont pas non endommagées et la JVM se termine.

Aniket Thakur
la source
5

En Java, les threads démon sont l'un des types de threads qui n'empêchent pas la sortie de la machine virtuelle Java (JVM). Le principal objectif d'un thread 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 sorties JVM, le thread démon meurt également.

En définissant a thread.setDaemon(true), un thread devient un thread démon. Cependant, vous ne pouvez définir cette valeur qu'avant le démarrage du thread.

Java Guru
la source
Quels sont les autres types de threads qui font cela? R: Aucun. Il existe des threads démon et des threads non démon, point final. C'est un binaire, deux états.
Marquis de Lorne
5

Voici un exemple pour tester le comportement des threads démon en cas de sortie jvm en raison de la non-existence de threads utilisateur.

Veuillez noter l'avant-dernière ligne dans la sortie ci-dessous, lorsque le thread principal est sorti, le thread démon est également mort et n'a pas imprimé l' instruction finalement exécutée9 dans le bloc enfin. Cela signifie que toutes les ressources d'E / S fermées dans le bloc finalement d'un thread démon ne seront pas fermées si la JVM se ferme en raison de l'absence 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");
  }
}

Production

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
Bharat Sharma
la source
4

Les threads démons sont, comme tout le monde l'a expliqué, ne contraindront pas JVM à quitter, donc en gros c'est un thread heureux pour Application du point de vue de la sortie.

Vous voulez ajouter que les threads démon peuvent être utilisés lorsque je dis que je fournis une API telle que la transmission de données vers un serveur tiers / ou JMS, je pourrais avoir besoin d'agréger des données au niveau de la machine virtuelle Java client, puis de les envoyer à JMS dans un thread séparé. Je peux faire ce fil comme fil de démon, si ce n'est pas une donnée obligatoire à pousser sur le serveur. Ce type de données est comme la transmission / agrégation de journaux.

Cordialement, Manish

Manish Malhotra
la source
Voici un programme simple montrant le thread démon en java. journaldev.com/1072/java-daemon-thread-example
Pankaj
4

Le thread démon est comme le processus démon qui est responsable de la gestion des ressources, un thread démon est créé par la machine virtuelle Java pour servir les threads utilisateur. exemple de mise à jour du système pour unix, unix est un processus démon. L'enfant du thread démon est toujours le thread démon, donc par défaut le démon est faux. Vous pouvez vérifier le thread en tant que démon ou utilisateur en utilisant la méthode "isDaemon ()". le thread démon ou le processus démon sont donc essentiellement responsables de la gestion des ressources. par exemple, lorsque vous démarrez jvm, il y a un garbage collector en cours d'exécution qui est un thread démon dont la priorité est 1 qui est la plus basse, qui gère la mémoire. jvm est vivant tant que le thread utilisateur est vivant, vous ne pouvez pas tuer le thread démon.jvm est responsable de tuer les threads démon.

user2663609
la source
Très confus, et tous les «so» ne sont pas séquentiels.
Marquis de Lorne
3

Parlons uniquement en code avec des exemples de travail. J'aime la réponse de russ ci-dessus, mais pour lever tout doute que j'avais, je l'ai un peu améliorée. Je l'ai exécuté deux fois, une fois avec le thread de travail défini sur deamon true (fil de démon) et une autre fois défini sur false (thread utilisateur). Il confirme que le thread 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
Tony
la source
3

Les threads démon sont généralement appelés threads "Service Provider". Ces threads ne doivent pas être utilisés pour exécuter du code programme mais du code système. Ces threads fonctionnent parallèlement à votre code mais la JVM peut les tuer à tout moment. Lorsque la JVM ne trouve aucun thread utilisateur, elle l'arrête et tous les threads démon se terminent instantanément. Nous pouvons définir un thread non démon sur démon en utilisant:

setDaemon(true)
Pankti
la source
3
Ils ne sont pas «généralement appelés« threads de fournisseur de services ».
Marquis de Lorne
1
Et ils peuvent être utilisés pour exécuter n'importe quel code. La JVM ne peut pas «les tuer à tout moment», mais elle les tuera quand aucun thread non-démon ne sera en cours d'exécution.
Marquis de Lorne
@EJP peut-être que je me trompe, mais "cela les tuera" lorsque des threads non démons s'exécutent. Lorsqu'un thread est un démon, ne s'exécute-t-il pas séparément en maintenant le jvm jusqu'à ce qu'il s'exécute complètement et soit maintenant géré au niveau du système d'exploitation.
89n3ur0n
Il les tuera lorsque tous les threads non démons seront terminés, et pas une picoseconde auparavant. Certainement pas «à tout moment».
Marquis de Lorne
3

Les threads 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, les threads démon sont arrêtés. Un exemple pour le thread non démon est le thread exécutant le Main. Un thread est fait démon en appelant la setDaemon()méthode avant le démarrage du thread

Pour plus de référence: thread démon en Java

Sai Sunder
la source
2

Pour moi, le thread démon, c'est comme le gardien de maison pour les threads utilisateur. Si tous les threads utilisateur sont terminés, le thread démon n'a aucun travail et est tué par JVM. Je l'ai expliqué dans la vidéo YouTube .

Gregory Nozik
la source
2

JVM accomplira le travail lorsqu'une dernière exécution de thread non démon est terminée. Par défaut, JVM créera 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 terminera son travail dès que tous les threads nondaemon seront terminés.

Arman Tumanyan
la source
comment cela peut-il être le fonctionnement du thread GC? Le garbage collection ne s'exécute-t-il pas même si le thread principal du programme prend très longtemps (le thread principal ne se termine pas)?
Calicoder
Comme je l'ai mentionné, le thread GC fonctionnera jusqu'à ce que la fin du dernier thread NON démon accomplisse son exécution. Le thread principal du programme n'est pas un démon comme nous le savons, donc le thread GC accomplira le travail une fois le thread principal terminé / tué. Fondamentalement, je veux dire que les threads démon se termineront lorsque le processus sera terminé, et le processus sera terminé lorsque tous les threads non démon seront exécutés.
Arman Tumanyan
Par défaut, le statut démon d'un thread est hérité de son parent.
Marquis de Lorne
-1

Les threads démons meurent à la fin du thread créateur.

Les threads non démons (par défaut) peuvent même vivre plus longtemps que le thread principal.

if ( threadShouldDieOnApplicationEnd ) {
    thread.setDaemon ( true );
}
thread.start();
Hans Wurst
la source
C'est faux. Il ne s'agit pas de fils de création. S'il y a un thread non utilisateur en cours d'exécution, les threads du démon continueront de s'exécuter. Cela peut être facilement testé en créant un thread de premier plan qui génère un thread démon. Même une fois le thread de premier plan joinédité, le démon reste aussi longtemps que le thread principal s'exécute.
Hubert Grzeskowiak
Les threads démon meurent lorsque la JVM n'est plus un thread non exécutable non démon. Voir le Javadoc. La réponse est complètement incorrecte.
Marquis de Lorne