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

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

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.

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.

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
            }
        }
    }
}

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 .

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>

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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.

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

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)

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

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 .

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.

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();