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

un thread de démon est un thread qui n'empêche pas le JVM de sortir lorsque le programme est terminé mais que le thread est toujours en cours d'exécution. Un exemple pour un fil de démon est la collecte des ordures.

vous pouvez utiliser la méthode setDaemon(boolean) pour changer les propriétés du démon Thread avant le début du thread.

quelques points de plus (Référence: Java Simultanéité dans la Pratique )

• Lorsqu'un nouveau fil est créé, il hérite du statut de démon de son parent.

• le fil Normal et le fil de démon diffèrent dans ce qui se passe quand ils sortent. Lorsque la JVM arrête tout autre fils de démon restants sont abandonné :

  • enfin les blocs ne sont pas exécuté ,
  Les piles
  • ne se détachent pas - le JVM sort tout simplement.
    
    
    
    

  en raison de cette raison fils de démon doit être utilisé avec parcimonie et il est dangereux de les utiliser pour des tâches

Toutes les réponses ci-dessus sont bonnes. Voici un petit extrait de code simple, pour illustrer la différence. Essayez avec chacune des valeurs de 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émon dans UNIX étaient ceux qui étaient constamment en cours d'exécution en arrière-plan, un peu comme les services dans Windows.

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

Avoir une lecture de fils de Démon .

les threads de Démon sont comme des fournisseurs de services pour d'autres threads ou objets tournant 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 de l'arrière-plan et ne sont nécessaires que pendant l'exécution des threads normaux. Si les threads normaux ne fonctionnent pas et que les threads restants sont des threads de démon, alors l'interpréteur sort.

par exemple, le navigateur HotJava utilise jusqu'à quatre fils de démon nommés "image Fetcher" pour récupérer des images du fichier système ou réseau pour tout thread qui en a besoin.

fils 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 différence essentielle entre les threads utilisateur et les threads démon est que la JVM n'arrête un programme que lorsque tous les threads utilisateur sont terminés. Les threads de démon sont interrompus par la JVM lorsqu'il n'y a plus de threads utilisateurs en cours d'exécution, y compris le thread principal de l'exécution.

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

public boolean isDaemon() ? cette méthode est utilisée pour déterminer si le fil est un fil de 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>

A daemon thread est un thread qui est considéré faire certaines tâches en arrière-plan comme le traitement des requêtes ou de diverses chronjobs qui peuvent exister dans une application.

quand votre programme ont seulement fils de démon restant il sortira. C'est parce que habituellement ces threads travaillent ensemble avec des threads normaux et fournissent la gestion d'arrière-plan des événements.

vous pouvez spécifier qu'un Thread est un démon un en utilisant setDaemon méthode, ils ne sortent généralement pas, ni ils sont interrompus.. ils arrêtent lorsque l'application s'arrête.

Définition de Démon(Informatique):

un processus d'arrière-plan qui traite les demandes de services tels que les services d'impression et de transfert de fichiers, et qui est inactif lorsqu'il n'est pas requis. Source

Qu'est-ce que le "daemon thread" en java?

• les fils de démon peuvent s'arrêter à tout moment entre leur flux, Non-démon, c'est-à-dire que le fil utilisateur s'exécute complètement.
• fils de démon exécute à une faible priorité.
• fils de Démon sont des fils qui fonctionnent de façon intermittente dans l'arrière-plan aussi longtemps que d'autres fils 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 de Démon sont des fournisseurs de services pour les threads d'utilisateur tournant dans le même processus.
• la ne vous souciez pas des fils de démon à compléter lorsque vous êtes dans L'état courant, même pas enfin bloquer permet aussi d'exécuter. JVM donnent la préférence aux threads Non-daemon qui sont créés par nous.
• fils de démon agit comme des services dans Windows.
• la JVM arrête les threads de démon lorsque tous les threads d'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 JVM dès que tous les threads utilisateurs se sont arrêtés.

un malentendu que je voudrais clarifier:

• supposons que si le fil de démon (disons B) est créé dans le fil d'utilisateur (disons A) ; alors la fin de ce thread utilisateur / thread parent (A) ne se terminera pas le thread daemon / child thread (B) qu'il a créé; à condition que le thread utilisateur soit le seul celui qui est actuellement en cours d'exécution.
• il n'y a donc pas de relation parent-enfant sur la fin du fil. Tous les fils de démon (indépendamment de l'endroit où il est créé) se termineront une fois il n'y a pas de thread utilisateur en direct et cela provoque L'arrêt de JVM.
• même si cela est vrai pour les deux (parent/enfant) sont des fils de démon.
• si un fil d'enfant créé à partir d'un fil de démon, alors c'est aussi un fil de démon. Ce n'aurez pas besoin explicite fil de démon paramètre d'indicateur. De même, si un thread enfant créé à partir d'un thread utilisateur est aussi un thread utilisateur, si vous voulez le modifier, alors il est nécessaire de définir explicitement un drapeau de démon avant le début de l'enfant thread.

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

• très faible priorité.
• ne s'exécute que lorsqu'aucun autre thread du même programme n'est en cours d'exécution.
• JVM termine le programme de finition de ces fils, lorsque les fils de démon sont les seuls threads qui tournent dans un programme.

à quoi servent les fils de démon?

normalement utilisé comme fournisseur de services pour les threads normaux. Généralement avoir une boucle infinie qui attend la demande de service ou exécute les tâches du thread. Ils ne peuvent pas faire d'importants travaux. (Parce que nous ne savons pas quand ils vont avoir du temps CPU et ils peuvent finir n'importe quand s'il n'y a pas d'autres threads en cours d'exécution. )

un exemple typique de ce type de fils est le Java garbage collector .

il y a plus...

• vous n'appelez que la méthode setDaemon() avant d'appeler la méthode start() . Une fois que le thread est lancé, vous ne pouvez pas modifier son statut de démon.
• utiliser la méthode isDaemon() pour vérifier si un thread est un thread de démon ou un thread utilisateur.

fils de démon et fils D'utilisateur. En général, tous les threads créés par le programmeur sont des threads utilisateur (sauf si vous spécifiez qu'il s'agit d'un "daemon" ou que votre thread parent est un "daemon thread"). Les threads utilisateurs sont généralement destinés à exécuter notre code de programme. JVM ne se termine pas à moins que tout le thread utilisateur ne se termine.

les fils de Démon sont comme des assistants. Les fils non-démoniaques sont comme les interprètes de devant. Les Assistants aident les interprètes à accomplir un travail. Lorsque le travail est terminé, aucune aide n'est nécessaire par des artistes pour effectuer plus. Comme aucune aide n'est nécessaire, les assistants quittent l'endroit. Ainsi, lorsque les travaux des threads Non-démon sont terminés, les threads démon s'éloignent.

le fil de Démon est comme un fil normal sauf que la JVM ne s'éteint que lorsque les autres fils non-démon ne sont pas existants. Les threads de démon sont généralement utilisés pour effectuer des services pour votre application.

les fils de démon en Java sont ces fils qui s'exécute en arrière-plan et la plupart du temps créé par JVM pour effectuer des tâches d'arrière-plan comme la collecte des ordures et d'autres tâches de ménage.

Points sont à Noter :

1. N'importe quel thread créé par le thread principal, qui exécute la méthode principale en Java est par défaut non daemon parce que le Thread hérite sa nature daemon du Thread qui le crée i.e. le Thread parent et puisque le thread principal est un thread non-démon, tout autre thread créé à partir de celui-ci restera non-démon jusqu'à ce qu'il soit explicitement fait démon en appelant setDaemon(true).

2. Thread.setDaemon (true) fait un démon de Thread mais il ne peut être appelé qu'avant le démarrage du Thread en Java. Il lancera IllegalThreadStateException si le Thread correspondant est déjà démarré et en cours d'exécution.

différence entre Fils de démon et non-démon en Java:

1) JVM n'attend pas qu'un fil de démon se termine avant d'exister.

2) Les Fils de Démon sont traités différemment des fils D'utilisateur lorsque JVM se termine, finalement les blocs ne sont pas appelés, Les piles ne sont pas déboulonnées et JVM se termine.

fils de Démon sont comme tout le monde expliqué, ne contraint pas JVM à sortir, donc essentiellement son un fil heureux pour L'Application du point de vue de sortie.

veut ajouter que les threads de démon peuvent être utilisés quand disons que je fournis une API comme pousser des données à un serveur tiers / ou JMS, je pourrais avoir besoin d'agréger des données au niveau JVM client et ensuite envoyer à JMS dans un thread séparé. Je peux faire ce thread comme thread de démon, si ce n'est pas une donnée obligatoire à pousser pour le serveur. Ce type de données est comme le journal de push / agrégation.

en ce qui Concerne, Manish

le thread de Démon est comme le processus de démon qui est responsable de la gestion des ressources,un thread de démon est créé par la VM Java pour servir les threads d'utilisateur. exemple de système de mise à jour pour unix,unix est un processus démon. l'enfant du thread de démon est toujours le thread de démon,donc par défaut le daemon est faux.vous pouvez vérifier le thread en tant que démon ou utilisateur en utilisant la méthode "isDaemon ()". afin de fil de démon ou démon processus sont responsables de la gestion des ressources. par exemple, lorsque vous lancez jvm il y a collecteur d'ordures courant qui est Fil de Démon dont la priorité est 1 qui est le plus bas, qui est la gestion de la mémoire. jvm est vivant tant que le thread utilisateur est vivant,u ne peut pas tuer le thread démon.la jvm est responsable de tuer les fils de démon.

fils de Démon sont généralement connus comme" fournisseur de services " fil. 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 JVM ne trouve aucun thread utilisateur, il l'arrête et tous les threads de démon se terminent instantanément. Nous pouvons définir le thread non-daemon à daemon en utilisant:

setDaemon(true)

en Java, fils de démon sont l'un des types de fil qui n'empêche pas Java Virtual Machine (JVM) de sortir. Le but principal d'un thread daemon est d'exécuter une tâche de fond en particulier dans le cas d'une tâche ou d'un travail périodique de routine. Avec les sorties JVM, le fil de démon meurt aussi.

en définissant un thread.setDaemon(true) , un fil devient un fil de démon. Cependant, vous ne pouvez définir cette valeur avant le début de fil.

tout fil Java peut être un fil de démon.

Les threads de démon sont des fournisseurs de services pour les autres threads tournant dans le même processus que le thread de démon. Par exemple, le HotJava browser utilise jusqu'à quatre fils de démon nommés " Image Fetcher " pour récupérer des images du système de fichiers ou du réseau pour tout fil qui en a besoin. La méthode run() pour un fil de démon est généralement une boucle infinie qui attend une demande de service. Lorsque les seuls threads restants dans un processus sont des threads de démon, l'interpréteur sort. Cela a du sens parce que lorsqu'il ne reste que des threads de démon, il n'y a aucun autre thread pour lequel un thread de démon peut fournir un service.

pour spécifier qu'un thread est un thread de démon, appelez la méthode setDaemon avec l'argument true. Pour déterminer si un thread est un thread démon, utilisez le méthode accessor isDaemon .

Espère que cela peut vous aider!!!!!!

les threads de Démon sont des threads qui tournent en arrière-plan aussi longtemps que d'autres threads non-démon du processus sont encore en cours d'exécution. Ainsi, lorsque tous les threads Non-démon sont terminés, les threads démon sont terminés. Un exemple pour le thread non-daemon est le thread tournant le Main. Un thread est fait démon en appelant la méthode setDaemon() avant que le thread ne soit démarré

Pour Plus d'Référence : Démon thread en Java

pour moi, fil de démon c'est comme gardien de maison pour fils d'utilisateur. Si tous les threads utilisateur sont finis , le thread démon n'a pas de travail et 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 supprimer tout doute que j'avais, je l'ai un peu améliorée. Je l'ai fait deux fois, une fois avec le thread worker réglé sur deamon true (thread deamon) et une autre fois avec false (user thread). Il confirme que le démon thread se termine lorsque le thread 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 lorsqu'une dernière exécution de thread non-daemon sera terminée. Par défaut, JVM va créer un thread en tant que nondaemon mais nous pouvons faire du Thread en tant que daemon avec 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 Non-Saemon seront terminés.

les fils de démon meurent lorsque le fil créateur disparaît.

threads Non-daemon (par défaut) peut même vivre plus longtemps que le thread principal.

if ( threadShouldDieOnApplicationEnd ) {
    thread.setDaemon ( true );
}
thread.start();

voici un exemple pour tester le comportement des threads de démon en cas de sortie jvm due à l'absence de threads d'utilisateur.

veuillez noter l'avant-dernière ligne de la sortie ci-dessous, lorsque le thread principal est sorti, le thread démon est également mort et n'a pas imprimé la déclaration finalement exécutée9 dans le bloc fin. Cela signifie que toutes les ressources d'e/s fermées dans le bloc final d'un thread de démon ne seront pas fermées si JVM sort en raison de l'absence de threads utilisateurs.

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