Cos'è un thread daemon in Java?

Qualcuno può dirmi quali thread demone sono in Java ?

Un thread daemon è un thread che non impedisce alla JVM di uscire al termine del programma ma il thread è ancora in esecuzione. Un esempio per un thread daemon è la garbage collection.

È possibile utilizzare il setDaemon(boolean)metodo per modificare le Threadproprietà del demone prima dell'avvio del thread.

Alcuni altri punti (Riferimento: Concorrenza Java in pratica )

• Quando viene creato un nuovo thread, eredita lo stato daemon del suo genitore.

• Al termine di tutti i thread non daemon, JVM si interrompe e tutti i thread daemon rimanenti vengono abbandonati :

  • infine i blocchi non vengono eseguiti ,
  • le pile non vengono srotolate: la JVM esce appena.
    
    

  Per questo motivo i thread demone devono essere usati con parsimonia, ed è pericoloso usarli per attività che potrebbero eseguire qualsiasi tipo di I / O.

Tutte le risposte sopra sono buone. Ecco un piccolo frammento di codice, per illustrare la differenza. Provalo con ciascuno dei valori di true e 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
            }
        }
    }
}

Tradizionalmente i processi daemon in UNIX erano quelli che erano costantemente in esecuzione in background, proprio come i servizi in Windows.

Un thread daemon in Java è uno che non impedisce alla JVM di uscire. In particolare, la JVM verrà chiusa quando rimangono solo thread daemon. Ne crei uno chiamando il setDaemon()metodo Thread.

Leggi i thread di Daemon .

I thread daemon sono come provider di servizi per altri thread o oggetti in esecuzione nello stesso processo del thread daemon. I thread daemon vengono utilizzati per attività di supporto in background e sono necessari solo durante l'esecuzione dei thread normali. Se i thread normali non sono in esecuzione e i thread rimanenti sono thread daemon, allora l'interprete esce.

Ad esempio, il browser HotJava utilizza fino a quattro thread demone denominati "Image Fetcher" per recuperare immagini dal file system o dalla rete per qualsiasi thread che ne abbia bisogno.

I thread daemon vengono generalmente utilizzati per eseguire servizi per l'applicazione / l'applet (ad esempio il caricamento dei "bit di fiddley"). La differenza principale tra thread utente e thread demone è che JVM chiuderà un programma solo quando tutti i thread utente saranno terminati. I thread daemon vengono terminati da JVM quando non ci sono più thread utente in esecuzione, incluso il thread principale di esecuzione.

setDaemon (true / false)? Questo metodo viene utilizzato per specificare che un thread è thread daemon.

pubblico booleano isDaemon ()? Questo metodo viene utilizzato per determinare se il thread è thread demone o meno.

Per esempio:

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

}

Produzione:

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>

Definizione di Demone (Informatica):

Un processo in background che gestisce le richieste di servizi come lo spooling di stampa e i trasferimenti di file ed è inattivo quando non richiesto.

—— Fonte: inglese dei dizionari di Oxford

Cos'è il thread Daemon in Java?

• I thread Daemon possono arrestarsi in qualsiasi momento tra il loro flusso, Non-Daemon, ovvero il thread utente viene eseguito completamente.
• I thread daemon sono thread che vengono eseguiti in modo intermittente in background fintanto che sono in esecuzione altri thread non daemon.
• Quando tutti i thread non daemon vengono completati, i thread daemon vengono chiusi automaticamente.
• I thread daemon sono fornitori di servizi per thread utente in esecuzione nello stesso processo.
• La JVM non si preoccupa del completamento dei thread daemon quando si trova nello stato In esecuzione, nemmeno il blocco infine consente l'esecuzione. JVM preferisce i thread non daemon creati da noi.
• I thread daemon fungono da servizi in Windows.
• JVM interrompe i thread del demone quando tutti i thread dell'utente (diversamente dai thread del demone) vengono terminati. Quindi i thread daemon possono essere utilizzati per implementare, ad esempio, una funzionalità di monitoraggio poiché il thread viene interrotto da JVM non appena tutti i thread utente sono stati arrestati.

Un thread daemon è un thread che viene considerato svolgere alcune attività in background come la gestione di richieste o vari chronjob che possono esistere in un'applicazione.

Quando il tuo programma ha solo thread demone rimanenti, verrà chiuso. Questo perché di solito questi thread lavorano insieme ai thread normali e forniscono la gestione in background degli eventi.

Puoi specificare che a Threadè un demone usando il setDaemonmetodo, di solito non escono, né sono interrotti .. si fermano appena quando l'applicazione si ferma.

Un malinteso che vorrei chiarire:

• Supponiamo che se il thread daemon (diciamo B) viene creato all'interno del thread utente (diciamo A); quindi la fine di questo thread utente / thread padre (A) non terminerà il thread demone / thread figlio (B) che ha creato; a condizione che il thread utente sia l'unico attualmente in esecuzione.
• Quindi non esiste una relazione genitore-figlio alla fine del thread. Tutti i thread demone (indipendentemente da dove viene creato) termineranno quando non vi è alcun thread utente live e ciò causa l'interruzione di JVM.
• Anche questo è vero per entrambi (genitore / figlio) sono thread demone.
• Se un thread figlio creato da un thread daemon, anche quello è un thread daemon. Ciò non richiederà alcuna impostazione di flag thread thread demone esplicito. Allo stesso modo se un thread figlio creato da un thread utente è anche un thread utente, se si desidera modificarlo, è necessario impostare un flag demone esplicito prima di iniziare quel thread figlio.

Discussione Daemon e Discussioni utente. Generalmente tutti i thread creati dal programmatore sono thread utente (a meno che non lo specifichi come demone o il tuo thread padre sia un thread demone). Il thread utente generalmente intende eseguire il nostro codice di programma. JVM non termina a meno che non venga interrotto tutto il thread utente.

Java ha un tipo speciale di thread chiamato thread demone .

• Priorità molto bassa.
• Viene eseguito solo quando nessun altro thread dello stesso programma è in esecuzione.
• JVM termina il programma finendo questi thread, quando i thread daemon sono gli unici thread in esecuzione in un programma.

A cosa servono i thread daemon?

Normalmente utilizzato come provider di servizi per thread normali. Di solito hanno un ciclo infinito che attende la richiesta di servizio o esegue le attività del thread. Non possono fare lavori importanti. (Perché non sappiamo quando avranno il tempo della CPU e possono finire in qualsiasi momento se non ci sono altri thread in esecuzione.)

Un tipico esempio di questo tipo di thread è il Garbage Collector Java .

C'è più...

• Si chiama il setDaemon()metodo solo prima di chiamare il start()metodo. Una volta che il thread è in esecuzione, non è possibile modificarne lo stato daemon.
• Utilizzare il isDaemon()metodo per verificare se un thread è un thread daemon o un thread utente.

I thread dei demoni sono come assistenti. I thread non Daemon sono come i front performer. Gli assistenti aiutano gli artisti a completare un lavoro. Quando il lavoro è completato, gli artisti non hanno più bisogno di aiuto per esibirsi. Poiché non è necessario alcun aiuto, gli assistenti lasciano il posto. Quindi, quando i lavori dei thread non Daemon sono finiti, i thread Daemon marciano via.

Il thread daemon è proprio come un normale thread, tranne per il fatto che JVM si spegnerà solo quando non sono presenti altri thread non daemon. I thread daemon vengono generalmente utilizzati per eseguire servizi per l'applicazione.

I thread daemon in Java sono quei thread che vengono eseguiti in background e principalmente creati da JVM per eseguire attività in background come Garbage Collection e altre attività di pulizia domestica.

Punti da notare:

1. Qualsiasi thread creato dal thread principale, che esegue il metodo principale in Java, per impostazione predefinita, non è un demone poiché Thread eredita la sua natura daemon dal thread che lo crea, ovvero il thread principale e poiché il thread principale è un thread non daemon, qualsiasi altro thread creato da esso verrà rimane non daemon fino a quando non viene creato esplicitamente un demone chiamando setDaemon (true).

2. Thread.setDaemon (true) crea un demone Thread ma può essere chiamato solo prima di avviare Thread in Java. Genera IllegalThreadStateException se il thread corrispondente è già avviato e in esecuzione.

Differenza tra thread Daemon e non Daemon in Java:

1) JVM non aspetta che un thread demone finisca prima di esistere.

2) Daemon Thread viene trattato in modo diverso rispetto a User Thread quando JVM termina, infine i blocchi non vengono chiamati, gli stack non vengono srotolati e JVM esce.

In Java, Daemon Threads è uno dei tipi di thread che non impedisce la chiusura di Java Virtual Machine (JVM). Lo scopo principale di un thread daemon è quello di eseguire attività in background, specialmente in caso di attività o lavori periodici di routine. Con l'uscita di JVM, muore anche il thread demone.

Impostando a thread.setDaemon(true), un thread diventa un thread demone. Tuttavia, è possibile impostare questo valore solo prima dell'inizio del thread.

Ecco un esempio per testare il comportamento dei thread demone in caso di uscita jvm a causa della non esistenza di thread utente.

Nota la seconda ultima riga nell'output di seguito, quando il thread principale è uscito, anche il thread daemon è morto e non ha stampato l' istruzione finalmente eseguita9 all'interno del blocco finally. Ciò significa che eventuali risorse di I / o chiuse all'interno del blocco di un thread daemon non verranno chiuse se JVM esce a causa della non esistenza di thread utente.

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

Produzione

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

I thread dei demoni sono come tutti hanno spiegato, non vincoleranno l'uscita di JVM, quindi sostanzialmente è un thread felice per l'applicazione dal punto di vista dell'uscita.

Vorrei aggiungere che i thread daemon possono essere usati quando dico che sto fornendo un'API come il push dei dati su un server di terze parti / o JMS, potrei aver bisogno di aggregare i dati a livello di client JVM e quindi inviarli a JMS in un thread separato. Posso creare questo thread come thread daemon, se non si tratta di un dato obbligatorio da inviare al server. Questo tipo di dati è come il push / aggregazione dei log.

Saluti, Manish

Il thread daemon è come il processo daemon che è responsabile della gestione delle risorse, un thread daemon viene creato dalla VM Java per servire i thread utente. esempio di aggiornamento del sistema per unix, unix è un processo daemon. il figlio del thread del daemon è sempre il thread del daemon, quindi per impostazione predefinita il daemon è false. È possibile controllare il thread come daemon o utente utilizzando il metodo "isDaemon ()". quindi il thread daemon o il processo daemon sono sostanzialmente responsabili della gestione delle risorse. per esempio quando avvii jvm c'è un garbage collector in esecuzione che è thread demone la cui priorità è 1 che è la più bassa, che gestisce la memoria. jvm è attivo fintanto che il thread utente è attivo, non è possibile uccidere daemon thread. jvm è responsabile dell'uccisione dei thread daemon.

Parliamo solo di codice con esempi funzionanti. Mi piace la risposta di Russ sopra, ma per rimuovere ogni dubbio che ho avuto, l'ho migliorata un po '. L'ho eseguito due volte, una volta con il thread di lavoro impostato su deamon true (thread deamon) e un'altra volta impostato su false (thread utente). Conferma che il thread Deamon termina quando termina il thread principale.

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

I thread daemon sono generalmente noti come thread "Service Provider". Questi thread non devono essere usati per eseguire il codice del programma ma il codice di sistema. Questi thread sono paralleli al tuo codice ma JVM può ucciderli in qualsiasi momento. Quando JVM non trova thread utente, lo interrompe e tutti i thread demone si interrompono all'istante. Possiamo impostare thread non daemon su daemon usando:

setDaemon(true)

I thread daemon sono thread che vengono eseguiti in background fintanto che altri thread non daemon del processo sono ancora in esecuzione. Pertanto, quando tutti i thread non daemon vengono completati, i thread daemon vengono terminati. Un esempio per il thread non daemon è il thread che esegue Main. Un thread viene creato daemon chiamando il setDaemon()metodo prima dell'avvio del thread

Per ulteriori riferimenti: thread demone in Java

Per me, il thread demone è come il guardiano di casa per i thread degli utenti. Se tutti i thread utente sono terminati, il thread demone non ha lavoro e viene ucciso da JVM. L'ho spiegato nel video di YouTube .

JVM eseguirà il lavoro quando verrà completata l'ultima esecuzione di thread non daemon. Per impostazione predefinita, JVM creerà un thread come nondaemon, ma possiamo fare Thread come demone con l'aiuto del metodo setDaemon(true). Un buon esempio di thread Daemon è il thread GC che completerà il suo lavoro non appena tutti i thread nondaemon saranno completati.

I thread del demone muoiono quando esce il thread del creatore.

I thread non daemon (impostazione predefinita) possono persino vivere più a lungo del thread principale.

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