Kann mir jemand sagen, welche Daemon-Threads in Java sind ?
Antworten:
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.
setDamon(boolean)kann nur aufgerufen werden, bevor der Thread gestartet wurde. Standardmäßig erbt der Thread den Dämonstatus seines übergeordneten Threads.
thread that does not prevent the JVM from exiting when the program finishes but the thread is still runningbedeutet also im Grunde, dass es dem JVM-Prozess, der den Thread gestartet hat, egal ist, ob der Daemon-Thread die Ausführung beendet hat oder nicht. Er endet nur von selbst, wenn alle normalen Threads die Ausführung beendet haben.
Noch ein paar Punkte (Referenz: Java Concurrency in der Praxis )
Wenn alle Nicht-Daemon-Threads beendet sind, wird die JVM angehalten und alle verbleibenden Daemon-Threads werden abgebrochen :
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.
finallyBlöcke ausgeführt, unabhängig davon, ob die Threads Daemon sind oder nicht. Rufen System.exit(…)Sie also nicht an, wenn Sie der Meinung sind, dass möglicherweise Threads ausgeführt werden, die E / A ausführen. Der einzige Unterschied besteht darin, dass die JVM ihre eigene Beendigung auslöst, wenn nur noch Daemon-Threads übrig sind.
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>
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
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:
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.
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...
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.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 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:
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.
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");
}
}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 exitedDaemon-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 0Daemon-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();joinbearbeitet wurde, bleibt der Dämon so lange bestehen, wie der Haupt-Thread ausgeführt wird.
ThreadJavadoc beschreibt, was sie sind: java.sun.com/javase/6/docs/api/java/lang/Thread.html