O que é um encadeamento daemon em Java?

Alguém pode me dizer quais são os threads do daemon em Java ?

Um encadeamento daemon é um encadeamento que não impede que a JVM saia quando o programa termina, mas o encadeamento ainda está em execução. Um exemplo para um encadeamento daemon é a coleta de lixo.

Você pode usar o setDaemon(boolean)método para alterar as Threadpropriedades do daemon antes do início do encadeamento.

Mais alguns pontos (Referência: Concorrência Java na Prática )

• Quando um novo encadeamento é criado, ele herda o status do daemon de seu pai.

• Quando todos os encadeamentos que não são daemon são concluídos, a JVM é interrompida e todos os encadeamentos restantes do daemon são abandonados :

  • finalmente os blocos não são executados ,
  • as pilhas não são desenroladas - a JVM acaba de sair.
    
    

  Por esse motivo, os encadeamentos daemon devem ser usados ​​com moderação 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, (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
            }
        }
    }
}

Tradicionalmente, os processos de daemon no UNIX eram aqueles que estavam constantemente em execução em segundo plano, como os serviços no Windows.

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

Leia os tópicos do Daemon .

Os encadeamentos daemon são como prestadores de serviços para outros encadeamentos ou objetos em execução no mesmo processo que o encadeamento daemon. Os encadeamentos daemon são usados ​​para tarefas de suporte em segundo plano e são necessários apenas enquanto os encadeamentos normais estão em execução. Se os threads normais não estiverem em execução e os threads restantes forem daemon, o intérprete será encerrado.

Por exemplo, o navegador HotJava usa até quatro encadeamentos de daemon chamados "Image Fetcher" para buscar imagens do sistema de arquivos ou da 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 "bits do fiddley"). A principal diferença entre os encadeamentos do usuário e daemon é que a JVM encerrará um programa apenas quando todos os encadeamentos do usuário forem finalizados. Os encadeamentos daemon são finalizados pela JVM quando não há mais encadeamentos de usuário em execução, incluindo o encadeamento principal de execução.

setDaemon (verdadeiro / falso)? Este método é usado para especificar que um thread é um 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");
    }

}

Resultado:

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>

Definição de Daemon (Computação):

Um processo em segundo plano que lida com solicitações de serviços, como spool de impressão e transferência de arquivos, e fica inativo quando não é necessário.

—— Fonte: Inglês por Oxford Dictionaries

O que é o thread do Daemon em Java?

• Os encadeamentos do Daemon podem desligar a qualquer momento entre seu fluxo; o Não-Daemon, ou seja, o encadeamento do usuário é executado completamente.
• Os encadeamentos daemon são encadeamentos executados intermitentemente em segundo plano, enquanto outros encadeamentos não daemon estiverem em execução.
• Quando todos os encadeamentos não daemon são concluídos, os encadeamentos do daemon terminam automaticamente.
• Os encadeamentos daemon são prestadores 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 Running, nem mesmo finalmente o bloco também permite executar. A JVM dá preferência aos encadeamentos não daemon criados por nós.
• Threads daemon atuam como serviços no Windows.
• A JVM para os encadeamentos do daemon quando todos os encadeamentos do usuário (em contraste com os encadeamentos do daemon) são finalizados. Portanto, os encadeamentos daemon podem ser utilizados para implementar, por exemplo, uma funcionalidade de monitoramento, pois o encadeamento é parado pela JVM assim que todos os encadeamentos do usuário são interrompidos.

Um encadeamento daemon é um encadeamento considerado como executando algumas tarefas em segundo plano, como manipular solicitações ou vários chronjobs que podem existir em um aplicativo.

Quando seu programa tiver apenas threads daemon restantes, ele será encerrado. Isso ocorre porque geralmente esses threads funcionam em conjunto com threads normais e fornecem manipulação de eventos em segundo plano.

Você pode especificar que a Threadé um daemon usando o setDaemonmétodo, eles geralmente não saem, nem são interrompidos. Eles apenas param quando o aplicativo para.

Gostaria de esclarecer um equívoco:

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

Threads do Daemon e Threads do Usuário. Geralmente todos os encadeamentos criados pelo programador são encadeamentos de usuário (a menos que você o especifique como daemon ou seu encadeamento pai é um encadeamento de daemon). O encadeamento 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.

Java possui um tipo especial de encadeamento chamado daemon thread.

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

Para que são utilizados os threads do daemon?

Normalmente usado como provedor de serviços para threads normais. Geralmente, há um loop infinito que aguarda a solicitação de serviço ou executa as tarefas do encadeamento. Eles não podem fazer trabalhos importantes. (Como 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ê chama o setDaemon()método apenas antes de chamá-lo start(). Depois que o encadeamento estiver em execução, você não poderá modificar o status do daemon.
• Use o isDaemon()método para verificar se um thread é um daemon ou um usuário.

Threads daemon são como assistentes. Threads que não são daemon são como executores frontais. Os assistentes ajudam os artistas a concluir um trabalho. Quando o trabalho é concluído, os artistas não precisam mais de ajuda para executá-lo. Como nenhuma ajuda é necessária, os assistentes deixam o local. Portanto, quando os trabalhos dos encadeamentos não-Daemon terminam, os encadeamentos do Daemon marcham.

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

O encadeamento daemon em Java é o encadeamento executado em segundo plano e criado principalmente pela JVM para executar tarefas em segundo plano, como coleta de lixo e outras tarefas de manutenção doméstica.

Pontos a serem observados:

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

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

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

1) A JVM não espera que nenhum encadeamento daemon seja concluído antes de existir.

2) O Daemon Thread é tratado de forma diferente do User Thread quando a JVM termina, finalmente os blocos não são chamados, as pilhas não são desenroladas e a JVM acaba de sair.

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

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

Aqui está um exemplo para testar o comportamento dos encadeamentos daemon no caso de saída da jvm devido à inexistência de encadeamentos do usuário.

Observe a segunda última linha na saída abaixo, quando o thread principal foi encerrado, o daemon thread também morreu e não imprimiu a instrução finalmente executada9 no bloco finalmente. Isso significa que qualquer recurso de E / S fechado no bloco finalmente de um encadeamento daemon não será fechado se a JVM sair devido à inexistê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");
  }
}

Resultado

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

Os encadeamentos do daemon são como todos explicaram, não restringirão a JVM a sair, portanto, basicamente, é um encadeamento feliz para o Aplicativo do ponto de vista de saída.

Deseja adicionar que os encadeamentos daemon possam ser usados ​​quando, digamos, eu estiver fornecendo uma API, como enviar dados para um servidor de terceiros / ou JMS, talvez seja necessário agregar dados no nível da JVM do cliente e depois enviar para o JMS em um encadeamento separado. Eu posso fazer esse encadeamento como encadeamento daemon, se esse não for um dado obrigatório a ser enviado ao servidor. Esse tipo de dados é como push / agregação de log.

Atenciosamente, Manish

O encadeamento daemon é como o processo do daemon responsável pelo gerenciamento de recursos; um encadeamento daemon é criado pela Java VM para atender aos encadeamentos do usuário. Por exemplo, sistema de atualização para unix, unix é um processo daemon. o filho do thread daemon é sempre o daemon thread, portanto, por padrão, o daemon é false. você pode verificar o thread como daemon ou usuário usando o método "isDaemon ()". portanto, o daemon thread ou o processo daemon são basicamente responsáveis ​​pelo gerenciamento de recursos. por exemplo, ao iniciar a jvm, há um coletor de lixo em execução que é um encadeamento daemon cuja prioridade é 1 que é mais baixa, que está gerenciando a memória. jvm está ativo enquanto o thread do usuário estiver ativo, você não pode matar o daemon thread.jvm é responsável por matar os threads do daemon.

Vamos falar apenas em código com exemplos de trabalho. Eu gosto da resposta de russ acima, mas para remover qualquer dúvida que tenha, aprimorei-a um pouco. Eu o executei duas vezes, uma vez com o segmento de trabalho definido como deamon true (segmento de deamon) e outro tempo definido como false (segmento de usuário). Confirma que o encadeamento do deamon termina quando o encadeamento 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, (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

Os encadeamentos daemon são geralmente conhecidos como encadeamento "Service Provider". Esses encadeamentos não devem ser usados ​​para executar o código do programa, mas o código do sistema. Esses threads são paralelos ao seu código, mas a JVM pode matá-los a qualquer momento. Quando a JVM não encontra encadeamentos de usuário, ele o interrompe e todos os encadeamentos do daemon terminam instantaneamente. Podemos definir um segmento que não seja daemon como daemon usando:

setDaemon(true)

Os encadeamentos daemon são encadeamentos executados em segundo plano, enquanto outros encadeamentos não daemon do processo ainda estiverem em execução. Assim, quando todos os encadeamentos não daemon são concluídos, os encadeamentos do daemon são encerrados. Um exemplo para o encadeamento não daemon é o encadeamento executando o Main. Um encadeamento é criado daemon chamando o setDaemon()método antes que o encadeamento seja iniciado

Para obter mais referência: Thread daemon em Java

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

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

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

Threads que não são daemon (padrão) podem viver mais que o thread principal.

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