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


Quelqu'un peut-il me dire ce que les fils de démon sont en Java?


635
2018-02-06 14:08


origine


Réponses:


Un thread démon est un thread qui n'empêche pas la JVM de se terminer lorsque le programme se termine mais que le thread est toujours en cours d'exécution. Un exemple de thread de démon est la garbage collection.

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


535
2018-02-06 14:10



Quelques points de plus (Référence: Java Concurrency en pratique)

  • Lorsqu'un nouveau thread est créé, il hérite du statut démon de son parent.
  • Les threads de threads et démons normaux diffèrent dans ce qui se passe quand ils sortent. Lorsque la JVM arrête tout reste les fils de démon sont abandonné:

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

    Pour cette raison, les fils de démon devrait être utilisé avec parcimonie et il est dangereux de les utiliser pour des tâches cela pourrait effectuer n'importe quel type d'E / S.


296
2018-02-06 14:41



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 de vrai et faux 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
            }
        }
    }
}

152
2018-03-09 00:54



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

Un thread de démon en Java est un thread qui n'empêche pas la JVM de se terminer. Plus précisément, la machine virtuelle Java se ferme lorsque seuls les threads de démon demeurent. Vous en créez un en appelant le setDaemon() méthode sur Thread.

Avoir une lecture de Fils de démon.


91
2018-02-06 14:11



Les threads de 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 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 s'exécutent pas et si les threads restants sont des threads démon, l'interpréteur se ferme.

Par exemple, le navigateur HotJava utilise jusqu'à quatre threads de démon appelé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 exécuter 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 JVM ne ferme un programme que lorsque tous les threads utilisateur sont terminés. Les threads de démon sont terminés par la JVM lorsqu'il n'y a plus de threads utilisateur en cours d'exécution, y compris le thread d'exécution principal.

setDaemon (vrai / faux)? 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>

52
2018-05-11 06:50



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

Lorsque votre programme n'a que fils de démon restant il va sortir. En effet, ces threads fonctionnent généralement avec des threads normaux et assurent la gestion en 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 s'arrêtent juste quand l'application s'arrête.


31
2018-02-06 14:12



Quel est le fil de Daemon dans Java?

  • Les threads de démon peuvent s'arrêter à tout moment entre leurs flux, les threads non-démon, c'est-à-dire les utilisateurs, s'exécutent complètement.
  • Les threads démon s'exécutent avec une priorité faible.
  • Les threads de démon sont des threads qui s'exécutent par intermittence en arrière-plan tant que d'autres threads non-daemon sont en cours d'exécution.
  • Lorsque tous les threads non-daemon 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 de démon à compléter quand elle est en état Running, même si elle n'est pas bloquée. Les JVM donnent la préférence aux threads non-démons créés par nous.
  • Les threads de démon agissent comme des services dans Windows.
  • La JVM arrête les threads du démon lorsque tous les threads utilisateur (contrairement aux threads du 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 lorsque le thread est arrêté par la JVM dès que tous les threads utilisateur sont arrêtés.

19
2017-07-24 06:07



Une idée fausse que je voudrais clarifier:

  • Supposons que si le thread démon (disons B) est créé dans le thread utilisateur (par exemple UNE); alors la fin de ce thread utilisateur / parent (A) ne s'arrêtera pas le thread démon / thread fils (B) qu'il a créé; thread utilisateur fourni est le seul un en cours d'exécution.
  • Il n'y a donc pas de relation parent-enfant à la fin du thread. Tous les threads de démon (indépendamment de l'endroit où il est créé) se termineront une fois qu'il n'y aura plus de thread utilisateur en direct et que la JVM se terminera.
  • Même cela est vrai pour les deux (parent / enfant) sont des fils de démon.
  • Si un thread enfant a été créé à partir d'un thread démon, il s'agit également d'un thread démon. Cela n'aura pas besoin d'un paramètre d'indicateur de thread de démon explicite. De même, si un thread enfant est créé à partir d'un thread utilisateur, alors il s'agit également d'un thread utilisateur, si vous souhaitez le modifier, un paramétrage explicite de l'indicateur daemon est nécessaire avant le démarrage de ce thread enfant.

15
2017-12-01 13:14



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

  • Très faible priorité.
  • Ne s'exécute que si aucun autre thread du même programme n'est en cours d'exécution.
  • JVM termine le programme finissant ces threads, lorsque les threads démons sont les seuls threads en cours d'exécution dans un programme.

A quoi servent les threads daemon?

Normalement utilisé comme fournisseur de services pour les threads normaux. Ont généralement une boucle infinie qui attend la demande de service ou effectue les tâches du thread. Ils ne peuvent pas faire d'emplois importants. (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 genre de fils est le Java garbage collector.

Il y a plus...

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

13
2017-08-25 12:19