O que é um thread daemon em Java?

Alguém pode me dizer o que os threads daemon estão em Java?

   

Um encadeamento do daemon é um encadeamento que não impede a saída da JVM quando o programa é concluído, mas o encadeamento ainda está em execução. Um exemplo para um encadeamento do daemon é a garbage collection.

Você pode usar o setDaemon(boolean) para alterar as propriedades do daemon de Thread antes do início do thread.

Mais alguns pontos (Referência: Java Concurrency in Practice )

  • Quando um novo segmento é criado, ele herda o status do daemon de seu pai.
  • Tópicos normais de thread e daemon diferem no que acontece quando eles saem. Quando a JVM pára, todos os threads restantes do daemon são abandonados :

    • finalmente os blocos não são executados ,
    • pilhas não são desenroladas – a JVM apenas sai.

    Devido a isso, os threads do daemon devem ser usados ​​com parcimônia e é perigoso usá-los para tarefas que possam executar qualquer tipo de E / S.

Todas as respostas acima são boas. Aqui está um pequeno trecho de código simples, para ilustrar a diferença. Experimente com cada um dos valores de true e false em 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, (ie when it's a user thread), // the Worker thread continues to run. // When true, (ie 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 } } } } 

Tradicionalmente, os processos daemon no UNIX eram aqueles que estavam constantemente rodando em segundo plano, muito parecidos com serviços no Windows.

Um encadeamento do daemon em Java é aquele que não impede a saída da JVM. Especificamente, a JVM sairá quando apenas os encadeamentos do daemon permanecerem. Você cria um chamando o método setDaemon() em Thread .

Faça uma leitura dos tópicos do Daemon .

Os threads do daemon são como um provedor de serviços para outros threads ou objects em execução no mesmo processo que o thread do daemon. Threads Daemon são usados ​​para tarefas de suporte em segundo plano e são necessários apenas enquanto threads normais estão sendo executados. Se os encadeamentos normais não estiverem em execução e os encadeamentos restantes forem encadeamentos do daemon, o interpretador será encerrado.

Por exemplo, o navegador HotJava usa até quatro encadeamentos do daemon chamados “Image Fetcher” para buscar imagens do sistema de arquivos ou rede para qualquer encadeamento que precise de um.

Os encadeamentos daemon geralmente são usados ​​para executar serviços para seu aplicativo / applet (como carregar os “fiddley bits”). A principal diferença entre encadeamentos do usuário e encadeamentos do daemon é que a JVM só desligará um programa quando todos os encadeamentos do usuário forem finalizados. Os encadeamentos do Daemon são finalizados pela JVM quando não há mais encadeamentos do usuário em execução, incluindo o encadeamento principal de execução.

setDaemon (true / false)? Este método é usado para especificar que um encadeamento é um encadeamento do daemon.

public boolean isDaemon ()? Este método é usado para determinar se o encadeamento é daemon ou não.

Por exemplo:

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

Saída:

 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> 

Um encadeamento do daemon é um encadeamento considerado fazer algumas tarefas em segundo plano, como lidar com solicitações ou vários cronogramas que podem existir em um aplicativo.

Quando seu programa tiver apenas threads daemon restantes, ele será encerrado. Isso ocorre porque geralmente esses encadeamentos funcionam em conjunto com encadeamentos normais e fornecem tratamento em segundo plano de events.

Você pode especificar que um Thread é um daemon usando o método setDaemon , eles geralmente não saem, nem são interrompidos … eles param quando o aplicativo é interrompido.

O que é o segmento Daemon em java?

  • Threads daemon podem desligar a qualquer momento entre o stream, Non-Daemon ou seja, thread do usuário é executado completamente.
  • Threads Daemon são executados em baixa prioridade.
  • Os encadeamentos do daemon são encadeamentos que são executados intermitentemente em segundo plano, desde que outros encadeamentos não pertencentes ao daemon estejam em execução.
  • Quando todos os encadeamentos não-daemon forem concluídos, os encadeamentos do daemon terminarão automaticamente.
  • Os encadeamentos do Daemon são provedores de serviços para encadeamentos de usuários em execução no mesmo processo.
  • A JVM não se preocupa com os encadeamentos do daemon para serem concluídos quando no estado Em Execução, nem mesmo finalmente o bloco também permite a execução. A JVM dá preferência a threads não daemon que são criadas por nós.
  • Os threads do daemon atuam como serviços no Windows.
  • A JVM interrompe os encadeamentos do daemon quando todos os encadeamentos do usuário (em contraste com os encadeamentos do daemon) são finalizados. Portanto, os encadeamentos do daemon podem ser usados ​​para implementar, por exemplo, uma funcionalidade de monitoramento, pois o encadeamento é interrompido pela JVM assim que todos os encadeamentos do usuário forem interrompidos.

Um equívoco que gostaria de esclarecer:

  • Suponha que se o encadeamento do daemon (digamos B) for criado dentro do encadeamento do usuário (digamos A); então o término deste thread de usuário / thread pai (A) não terminará o encadeamento / thread filho do daemon (B) que ele criou; O thread do usuário fornecido é o único atualmente em execução.
  • Portanto, não há relacionamento pai-filho no final do segmento. Todos os encadeamentos do daemon (independentemente de onde ele é criado) terminarão quando não houver um único encadeamento do usuário ativo e isso fizer com que a JVM seja finalizada.
  • Mesmo isso é verdade para ambos (pai / filho) são threads daemon.
  • Se um encadeamento filho criado a partir de um encadeamento do daemon, também será um encadeamento do daemon. Isso não precisará de nenhuma configuração de sinalizador de encadeamento do daemon explícito. Da mesma forma, se um encadeamento filho criado a partir de um encadeamento do usuário for um encadeamento do usuário, se você quiser alterá-lo, a definição do sinalizador do daemon explícito será necessária antes do início desse encadeamento filho.

Java tem um tipo especial de thread chamado thread daemon .

  • Prioridade muito baixa.
  • Só executa quando nenhum outro thread do mesmo programa está sendo executado.
  • A JVM termina o programa finalizando esses encadeamentos, quando os encadeamentos do daemon são os únicos encadeamentos em execução em um programa.

Quais são os threads daemon usados ​​para?

Normalmente usado como provedor de serviços para encadeamentos normais. Geralmente, tem um loop infinito que aguarda a solicitação de serviço ou executa as tarefas do encadeamento. Eles não podem fazer trabalhos importantes. (Porque não sabemos quando eles terão tempo de CPU e poderão terminar a qualquer momento se não houver outros threads em execução.)

Um exemplo típico desse tipo de encadeamento é o coletor de lixo Java .

Tem mais…

  • Você só chama o método setDaemon() antes de chamar o método start() . Quando o encadeamento estiver em execução, você não poderá modificar seu status de daemon.
  • Use o método isDaemon() para verificar se um encadeamento é um encadeamento do daemon ou um encadeamento do usuário.

Thread Daemon e Threads do Usuário. Geralmente, todos os threads criados pelo programador são thread do usuário (a menos que você especifique para ser daemon ou o thread pai é um thread do daemon). O segmento do usuário geralmente serve para executar nosso código de programa. A JVM não termina a menos que todo o encadeamento do usuário seja finalizado.

Threads daemon são como assistentes. Threads que não são daemon são como front performers. Assistentes ajudam os artistas a concluir um trabalho. Quando o trabalho é concluído, não é necessária ajuda por parte dos artistas para executar mais. Como não é necessária ajuda, os assistentes deixam o local. Então, quando os trabalhos de threads não-Daemon terminam, os threads Daemon se afastam.

O encadeamento do daemon é exatamente como um encadeamento normal, exceto que a JVM só será encerrada quando os outros encadeamentos não daemon não existirem. Os encadeamentos daemon geralmente são usados ​​para executar serviços para seu aplicativo.

O encadeamento do daemon em Java é aquele encadeado executado em segundo plano e criado principalmente pela JVM para executar tarefas em segundo plano, como garbage collection e outras tarefas de manutenção.

Pontos a serem observados:

  1. Qualquer encadeamento criado pelo encadeamento principal, que executa o método main em Java, é por padrão não daemon porque Thread herda sua natureza de daemon do encadeamento que o cria, ou seja, encadeamento pai e como encadeamento principal é um encadeamento não daemon, qualquer outro encadeamento criado a partir dele permaneça não-daemon até que o daemon seja explicitamente chamado setDaemon (true).

  2. Thread.setDaemon (true) cria um daemon de Thread, mas ele só pode ser chamado antes de iniciar o Thread em Java. Ele lançará IllegalThreadStateException se o segmento correspondente já estiver iniciado e em execução.

Diferença entre Daemon e Non Daemon thread em Java:

1) A JVM não espera que qualquer encadeamento do daemon termine antes de existir.

2) O Daemon Thread é tratado de maneira diferente do Thread de Usuário quando a JVM é finalizada, finalmente os blocos não são chamados, as Stacks não são desenroladas e a JVM simplesmente sai.

Threads do Daemon são como todo mundo explicou, não irá restringir a JVM para sair, então basicamente é um tópico feliz para o Application from exit point of view.

Deseja adicionar que os encadeamentos do daemon possam ser usados ​​quando disser que estou fornecendo uma API como enviar dados para um servidor de terceiros / ou JMS, posso precisar agregar dados no nível de JVM do cliente e enviá-los para o JMS em um encadeamento separado. Eu posso fazer este segmento como thread daemon, se isso não é um dado obrigatório para ser enviado para o servidor. Esse tipo de dado é como log push / aggregation.

Atenciosamente, Manish

O daemon thread é como o processo daemon, que é responsável pelo gerenciamento de resources, um thread daemon é criado pela Java VM para atender aos threads do usuário. exemplo de sistema de atualização para unix, unix é um processo daemon. O filho do daemon thread é sempre daemon thread, portanto, por padrão, o daemon é false.you pode verificar o thread como daemon ou usuário usando o método “isDaemon ()”. assim, o daemon thread ou o processo daemon são basicamente responsáveis ​​pelo gerenciamento de resources. por exemplo, quando você inicia o jvm, há um coletor de lixo em execução que é o daemon cuja prioridade é 1, que é a mais baixa, que é o gerenciamento da memory. jvm está vivo desde que o thread do usuário esteja ativo, vc não pode matar o daemon thread.jvm é responsável por matar os threads do daemon.

Segmentos de daemon são geralmente conhecidos como segmento de “Provedor de serviço”. Esses encadeamentos não devem ser usados ​​para executar código de programa, mas código de sistema. Esses encadeamentos são executados paralelamente ao seu código, mas a JVM pode eliminá-los a qualquer momento. Quando a JVM não encontra encadeamentos do usuário, ela pára e todos os encadeamentos do daemon terminam instantaneamente. Podemos definir um thread não-daemon para daemon usando:

 setDaemon(true) 

Em Java, os Daemon Threads são um dos tipos de encadeamento que não impedem a saída da Java Virtual Machine (JVM). O objective principal de um encadeamento do daemon é executar uma tarefa em segundo plano, especialmente no caso de alguma tarefa ou trabalho periódico de rotina. Com saídas de JVM, o thread do daemon também morre.

Definindo um thread.setDaemon(true) , um thread se torna um thread do daemon. No entanto, você só pode definir esse valor antes do início do segmento.

Qualquer encadeamento Java pode ser um encadeamento do daemon.

Os threads do Daemon são provedores de serviços para outros threads em execução no mesmo processo que o thread do daemon. Por exemplo, o navegador HotJava usa até quatro encadeamentos do daemon chamados “Image Fetcher” para buscar imagens do sistema de arquivos ou rede para qualquer encadeamento que precise de um. O método run() para um encadeamento do daemon é tipicamente um loop infinito que aguarda por um pedido de serviço. Quando os únicos threads restantes em um processo são threads do daemon, o interpretador é encerrado. Isso faz sentido porque, quando apenas os encadeamentos do daemon permanecem, não há outro encadeamento para o qual um encadeamento do daemon possa fornecer um serviço.

Para especificar que um encadeamento é um encadeamento do daemon, chame o método setDaemon com o argumento true. Para determinar se um encadeamento é um encadeamento do daemon, use o método do isDaemon .

Espero que isso possa ajudar !!!!!!

Threads do Daemon são encadeamentos que são executados em segundo plano, desde que outros encadeamentos não pertencentes ao daemon do processo ainda estejam em execução. Assim, quando todos os encadeamentos não-daemon forem concluídos, os encadeamentos do daemon serão finalizados. Um exemplo para o segmento não-daemon é o segmento executando o Main. Um encadeamento é feito pelo daemon chamando o método setDaemon() antes que o encadeamento seja iniciado

Para mais referência: thread Daemon em Java

Para mim, o daemon thread é como o house keeper para threads do usuário. Se todos os encadeamentos do usuário forem concluídos, o encadeamento do daemon não terá nenhum job e será morto pela JVM. Eu expliquei no vídeo do YouTube .

Vamos falar apenas em código com exemplos de trabalho. Eu gosto da resposta de Russ acima, mas para remover qualquer dúvida que tive, eu aumentei um pouco. Eu corri duas vezes, uma vez com o thread de trabalho definido como deamon true (thread deamon) e outra hora configurada como false (thread do usuário). Confirma que o thread deamon termina quando o thread principal termina.

 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, (ie when it's a user thread), // the Worker thread continues to run. // When true, (ie 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 

A JVM realizará o trabalho quando uma última execução de thread não-daemon for concluída. Por padrão, a JVM criará um encadeamento como nondaemon, mas podemos fazer o Thread como um daemon com a ajuda do método setDaemon(true) . Um bom exemplo de thread Daemon é o segmento GC, que completará seu trabalho assim que todos os threads não-daemon forem concluídos.

Os threads do Daemon morrem quando o thread do criador sai.

Threads não daemon (padrão) podem até mesmo viver mais do que o thread principal.

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

Aqui está um exemplo para testar o comportamento de threads do daemon no caso de saída do jvm devido à não existência de threads do usuário.

Por favor, note a segunda última linha na saída abaixo, quando o thread principal saiu, o thread do daemon também morreu e não imprimiu finalmente a instrução executada9 no bloco finally. Isso significa que quaisquer resources de E / S fechados dentro do bloco finally de um encadeamento do daemon não serão fechados se a JVM sair devido à não existência de encadeamentos do usuário.

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

Saída

 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