Was ist ein Daemon-Thread in Java?

Kann mir jemand sagen, welche Daemon-Threads in Java sind ?

Ein Daemon-Thread ist ein Thread, der nicht verhindert, dass die JVM beendet wird, wenn das Programm beendet wird, der Thread jedoch noch ausgeführt wird. Ein Beispiel für einen Daemon-Thread ist die Garbage Collection.

Mit dieser setDaemon(boolean)Methode können Sie die ThreadDaemon-Eigenschaften ändern, bevor der Thread gestartet wird.

Noch ein paar Punkte (Referenz: Java Concurrency in der Praxis )

• Wenn ein neuer Thread erstellt wird, erbt er den Dämonstatus seines übergeordneten Threads.

• Wenn alle Nicht-Daemon-Threads beendet sind, wird die JVM angehalten und alle verbleibenden Daemon-Threads werden abgebrochen :

  • Schließlich werden Blöcke nicht ausgeführt .
  • Stapel werden nicht abgewickelt - die JVM wird einfach beendet.
    
    

  Aus diesem Grund sollten Daemon-Threads sparsam verwendet werden, und es ist gefährlich, sie für Aufgaben zu verwenden, bei denen möglicherweise E / A-Vorgänge ausgeführt werden.

Alle obigen Antworten sind gut. Hier ist ein einfaches kleines Code-Snippet, um den Unterschied zu veranschaulichen. Versuchen Sie es mit jedem der Werte true und 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
            }
        }
    }
}

Traditionell waren Daemon-Prozesse unter UNIX solche, die ständig im Hintergrund ausgeführt wurden, ähnlich wie Dienste unter Windows.

Ein Daemon-Thread in Java verhindert nicht, dass die JVM beendet wird. Insbesondere wird die JVM beendet, wenn nur noch Daemon-Threads übrig sind. Sie erstellen eine, indem Sie die setDaemon()Methode aufrufen Thread.

Lesen Sie Daemon-Threads .

Daemon-Threads sind wie Dienstanbieter für andere Threads oder Objekte, die im selben Prozess wie der Daemon-Thread ausgeführt werden. Daemon-Threads werden für unterstützende Hintergrundaufgaben verwendet und nur benötigt, während normale Threads ausgeführt werden. Wenn keine normalen Threads ausgeführt werden und die verbleibenden Threads Daemon-Threads sind, wird der Interpreter beendet.

Beispielsweise verwendet der HotJava-Browser bis zu vier Daemon-Threads mit dem Namen "Image Fetcher", um Bilder aus dem Dateisystem oder Netzwerk für jeden Thread abzurufen, der einen benötigt.

Daemon-Threads werden normalerweise verwendet, um Dienste für Ihre Anwendung / Ihr Applet auszuführen (z. B. das Laden der "Fiddley-Bits"). Der Hauptunterschied zwischen Benutzer-Threads und Daemon-Threads besteht darin, dass die JVM ein Programm nur herunterfährt, wenn alle Benutzer-Threads beendet wurden. Daemon-Threads werden von der JVM beendet, wenn keine Benutzer-Threads mehr ausgeführt werden, einschließlich des Hauptausführungsthreads.

setDaemon (wahr / falsch)? Diese Methode wird verwendet, um anzugeben, dass ein Thread ein Daemon-Thread ist.

public boolean isDaemon ()? Diese Methode wird verwendet, um festzustellen, ob der Thread ein Daemon-Thread ist oder nicht.

Z.B:

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");
    }

}

Ausgabe:

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>

Definition von Daemon (Computing):

Ein Hintergrundprozess, der Anforderungen für Dienste wie Druckspooling und Dateiübertragungen verarbeitet und inaktiv ist, wenn er nicht benötigt wird.

—— Quelle: Englisch von Oxford Dictionaries

Was ist ein Daemon-Thread in Java?

• Daemon-Threads können jederzeit zwischen ihren Flows heruntergefahren werden. Nicht-Daemon-Threads werden vollständig ausgeführt.
• Daemon-Threads sind Threads, die zeitweise im Hintergrund ausgeführt werden, solange andere Nicht-Daemon-Threads ausgeführt werden.
• Wenn alle Nicht-Daemon-Threads abgeschlossen sind, werden Daemon-Threads automatisch beendet.
• Daemon-Threads sind Dienstanbieter für Benutzer-Threads, die im selben Prozess ausgeführt werden.
• Die JVM kümmert sich nicht darum, dass Daemon-Threads im laufenden Zustand abgeschlossen werden, nicht einmal endgültig blockieren, sondern auch ausführen lassen. JVM bevorzugt Nicht-Daemon-Threads, die von uns erstellt wurden.
• Daemon-Threads fungieren in Windows als Dienste.
• Die JVM stoppt die Daemon-Threads, wenn alle Benutzer-Threads (im Gegensatz zu den Daemon-Threads) beendet werden. Daher können Daemon-Threads verwendet werden, um beispielsweise eine Überwachungsfunktion zu implementieren, wenn der Thread von der JVM gestoppt wird, sobald alle Benutzer-Threads gestoppt wurden.

Ein Daemon-Thread ist ein Thread, bei dem einige Aufgaben im Hintergrund ausgeführt werden, z. B. das Behandeln von Anforderungen oder verschiedene Chronjobs, die in einer Anwendung vorhanden sein können.

Wenn Ihr Programm nur noch Daemon-Threads hat, wird es beendet. Dies liegt daran, dass diese Threads normalerweise mit normalen Threads zusammenarbeiten und die Hintergrundbehandlung von Ereignissen ermöglichen.

Sie können mithilfe der Methode angeben, dass a Threadein DaemonsetDaemon ist. Sie werden normalerweise nicht beendet und auch nicht unterbrochen. Sie werden nur gestoppt, wenn die Anwendung gestoppt wird.

Ein Missverständnis, das ich klarstellen möchte:

• Angenommen, wenn ein Daemon-Thread (z. B. B) innerhalb des Benutzerthreads (z. B. A) erstellt wird; Durch das Beenden dieses Benutzer-Threads / übergeordneten Threads (A) wird der von ihm erstellte Daemon-Thread / untergeordnete Thread (B) nicht beendet. vorausgesetzt, der Benutzerthread ist der einzige, der derzeit ausgeführt wird.
• Es gibt also keine Eltern-Kind-Beziehung zum Thread-Ende. Alle Daemon-Threads (unabhängig davon, wo sie erstellt wurden) werden beendet, sobald kein einzelner Live-Benutzer-Thread vorhanden ist und JVM beendet wird.
• Auch dies gilt für beide (Eltern / Kind) sind Daemon-Threads.
• Wenn ein untergeordneter Thread aus einem Daemon-Thread erstellt wurde, ist dies auch ein Daemon-Thread. Dies erfordert keine explizite Einstellung des Daemon-Thread-Flags. Wenn ein untergeordneter Thread aus einem Benutzer-Thread erstellt wurde, ist dies ebenfalls ein Benutzer-Thread. Wenn Sie ihn ändern möchten, ist vor dem Start dieses untergeordneten Threads eine explizite Einstellung des Daemon-Flags erforderlich.

Daemon-Thread und Benutzer-Threads. Im Allgemeinen sind alle vom Programmierer erstellten Threads Benutzer-Threads (es sei denn, Sie geben an, dass es sich um einen Daemon handelt oder Ihr übergeordneter Thread ist ein Daemon-Thread). Benutzer-Threads sind im Allgemeinen dazu gedacht, unseren Programmcode auszuführen. JVM wird erst beendet, wenn alle Benutzer-Threads beendet sind.

Java hat eine spezielle Art von Thread namens Daemon- Thread.

• Sehr niedrige Priorität.
• Wird nur ausgeführt, wenn kein anderer Thread desselben Programms ausgeführt wird.
• JVM beendet das Programm und beendet diese Threads, wenn Daemon-Threads die einzigen Threads sind, die in einem Programm ausgeführt werden.

Wofür werden Daemon-Threads verwendet?

Wird normalerweise als Dienstanbieter für normale Threads verwendet. Normalerweise haben Sie eine Endlosschleife, die auf die Serviceanforderung wartet oder die Aufgaben des Threads ausführt. Sie können keine wichtigen Aufgaben erledigen. (Weil wir nicht wissen, wann sie CPU-Zeit haben werden und sie jederzeit beenden können, wenn keine anderen Threads ausgeführt werden.)

Ein typisches Beispiel für diese Art von Threads ist der Java Garbage Collector .

Es gibt mehr...

• Sie rufen die setDaemon()Methode nur auf, bevor Sie die start()Methode aufrufen . Sobald der Thread ausgeführt wird, können Sie seinen Dämonstatus nicht mehr ändern.
• Verwenden Sie die isDaemon()Methode, um zu überprüfen, ob ein Thread ein Daemon-Thread oder ein Benutzer-Thread ist.

Daemon-Threads sind wie Assistenten. Nicht-Daemon-Threads sind wie Front-Performer. Assistenten helfen den Darstellern, einen Job zu erledigen. Wenn der Auftrag abgeschlossen ist, benötigen die Darsteller keine Hilfe mehr, um die Leistung zu erbringen. Da keine Hilfe benötigt wird, verlassen die Assistenten den Ort. Wenn die Jobs von Nicht-Daemon-Threads beendet sind, marschieren Daemon-Threads weg.

Daemon-Thread ist wie ein normaler Thread, außer dass die JVM nur heruntergefahren wird, wenn die anderen Nicht-Daemon-Threads nicht vorhanden sind. Daemon-Threads werden normalerweise verwendet, um Dienste für Ihre Anwendung auszuführen.

Daemon-Thread in Java sind solche Threads, die im Hintergrund ausgeführt werden und hauptsächlich von JVM für die Ausführung von Hintergrundaufgaben wie Garbage Collection und anderen Haushaltsaufgaben erstellt wurden.

Zu beachtende Punkte:

1. Jeder vom Hauptthread erstellte Thread, der die Hauptmethode in Java ausführt, ist standardmäßig kein Daemon, da der Thread seine Daemon-Natur vom Thread erbt, der ihn erstellt, dh vom übergeordneten Thread, und da der Hauptthread ein Nicht-Daemon-Thread ist, wird jeder andere daraus erstellte Thread Bleiben Sie kein Daemon, bis Sie durch Aufrufen von setDaemon (true) explizit zum Daemon gemacht werden.

2. Thread.setDaemon (true) erstellt einen Thread-Daemon, der jedoch nur vor dem Starten von Thread in Java aufgerufen werden kann. Es wird eine IllegalThreadStateException ausgelöst, wenn der entsprechende Thread bereits gestartet ist und ausgeführt wird.

Unterschied zwischen Daemon- und Non-Daemon-Thread in Java:

1) JVM wartet nicht, bis ein Daemon-Thread beendet ist, bevor er vorhanden ist.

2) Daemon-Thread werden anders behandelt als User-Thread, wenn JVM beendet wird, schließlich werden Blöcke nicht aufgerufen, Stacks werden nicht abgewickelt und JVM wird einfach beendet.

In Java sind Daemon-Threads einer der Thread-Typen, die das Beenden von Java Virtual Machine (JVM) nicht verhindern. Der Hauptzweck eines Daemon-Threads besteht darin, eine Hintergrundaufgabe auszuführen, insbesondere im Fall einer routinemäßigen periodischen Aufgabe oder Arbeit. Bei JVM-Exits stirbt auch der Daemon-Thread.

Durch Setzen von a thread.setDaemon(true)wird ein Thread zu einem Daemon-Thread. Sie können diesen Wert jedoch nur vor dem Start des Threads festlegen.

Hier ist ein Beispiel zum Testen des Verhaltens von Daemon-Threads im Falle eines JVM-Exits aufgrund des Fehlens von Benutzer-Threads.

Bitte beachten Sie, dass die zweitletzte Zeile in der Ausgabe unten beim Beenden des Hauptthreads auch der Daemon-Thread gestorben ist und die Anweisung finally execute9 innerhalb des Blocks finally nicht gedruckt hat . Dies bedeutet, dass alle E / A-Ressourcen, die innerhalb des endgültigen Blocks eines Daemon-Threads geschlossen wurden, nicht geschlossen werden, wenn JVM aufgrund des Fehlens von Benutzer-Threads beendet wird.

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");
  }
}

Ausgabe

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

Daemon-Threads sind, wie jeder erklärt hat, nicht gezwungen, JVM zu beenden, daher ist es im Grunde genommen ein fröhlicher Thread für die Anwendung aus der Sicht des Exits.

Wenn Sie hinzufügen möchten, dass Daemon-Threads verwendet werden können, wenn ich beispielsweise eine API wie das Pushen von Daten an einen Server / oder ein JMS eines Drittanbieters bereitstelle, muss ich möglicherweise Daten auf Client-JVM-Ebene aggregieren und dann in einem separaten Thread an JMS senden. Ich kann diesen Thread als Daemon-Thread erstellen, wenn dies keine obligatorischen Daten sind, die an den Server übertragen werden sollen. Diese Art von Daten ist wie Protokoll-Push / Aggregation.

Grüße, Manish

Daemon-Thread ist wie ein Daemon-Prozess, der für die Verwaltung von Ressourcen verantwortlich ist. Ein Daemon-Thread wird von der Java-VM erstellt, um die Benutzer-Threads zu bedienen. Beispiel für die Aktualisierung des Systems für Unix, Unix ist ein Daemon-Prozess. Das untergeordnete Element des Daemon-Threads ist immer ein Daemon-Thread, daher ist der Daemon standardmäßig false. Sie können den Thread als Daemon oder Benutzer mithilfe der Methode "isDaemon ()" überprüfen. Daher sind Daemon-Threads oder Daemon-Prozesse grundsätzlich für die Verwaltung von Ressourcen verantwortlich. Wenn Sie beispielsweise jvm starten, wird ein Garbage Collector ausgeführt, bei dem es sich um einen Daemon-Thread handelt, dessen Priorität 1 ist, der am niedrigsten ist und der den Speicher verwaltet. jvm ist am Leben, solange der Benutzer-Thread aktiv ist. Sie können den Daemon-Thread nicht beenden. jvm ist dafür verantwortlich, Daemon-Threads zu beenden.

Sprechen wir nur im Code mit Arbeitsbeispielen. Ich mag Russ 'Antwort oben, aber um jeden Zweifel zu beseitigen, den ich hatte, habe ich sie ein wenig verbessert. Ich habe es zweimal ausgeführt, einmal mit dem Worker-Thread auf deamon true (deamon-Thread) und ein anderes Mal auf false (User-Thread). Es bestätigt, dass der Deamon-Thread endet, wenn der Haupt-Thread endet.

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

Daemon-Threads werden allgemein als "Service Provider" -Thread bezeichnet. Diese Threads sollten nicht zum Ausführen von Programmcode, sondern von Systemcode verwendet werden. Diese Threads laufen parallel zu Ihrem Code, aber JVM kann sie jederzeit beenden. Wenn JVM keine Benutzer-Threads findet, wird es gestoppt und alle Daemon-Threads werden sofort beendet. Wir können Nicht-Daemon-Thread auf Daemon setzen, indem wir:

setDaemon(true)

Daemon-Threads sind Threads, die im Hintergrund ausgeführt werden, solange andere Nicht-Daemon-Threads des Prozesses noch ausgeführt werden. Wenn alle Nicht-Daemon-Threads abgeschlossen sind, werden die Daemon-Threads beendet. Ein Beispiel für den Nicht-Daemon-Thread ist der Thread, auf dem Main ausgeführt wird. Ein Thread wird zum Daemon gemacht, indem die setDaemon()Methode aufgerufen wird, bevor der Thread gestartet wird

Weitere Informationen: Daemon-Thread in Java

Für mich ist Daemon-Thread wie ein House Keeper für Benutzer-Threads. Wenn alle Benutzer-Threads beendet sind, hat der Daemon-Thread keinen Job und wird von JVM beendet. Ich habe es im YouTube-Video erklärt .

JVM führt die Arbeit aus, wenn eine letzte Nicht-Daemon-Thread-Ausführung abgeschlossen ist. Standardmäßig erstellt JVM einen Thread als Nondaemon, aber wir können Thread mithilfe der Methode als Daemon erstellen setDaemon(true). Ein gutes Beispiel für einen Daemon-Thread ist der GC-Thread, der seine Arbeit abschließt, sobald alle Nondaemon-Threads abgeschlossen sind.

Daemon-Threads sterben ab, wenn der Ersteller-Thread beendet wird.

Nicht-Daemon-Threads (Standard) können sogar länger als der Haupt-Thread leben.

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