¿Qué es un hilo de demonio en Java?

¿Alguien puede decirme qué hilos de daemon hay en Java ?

Un subproceso de daemon es un subproceso que no impide que la JVM salga cuando finaliza el programa pero el subproceso aún se está ejecutando. Un ejemplo para un hilo de daemon es la recolección de basura.

Puede usar el setDaemon(boolean)método para cambiar las Threadpropiedades del demonio antes de que comience el hilo.

Algunos puntos más (Referencia: concurrencia de Java en la práctica )

• Cuando se crea un nuevo hilo, hereda el estado del demonio de su padre.

• Cuando finalizan todos los subprocesos que no son de daemon, la JVM se detiene y se abandonan los subprocesos de daemon restantes :

  • finalmente los bloques no se ejecutan ,
  • las pilas no se desenrollan: la JVM simplemente se cierra.
    
    

  Debido a esta razón, los hilos de daemon deben usarse con moderación, y es peligroso usarlos para tareas que puedan realizar cualquier tipo de E / S.

Todas las respuestas anteriores son buenas. Aquí hay un pequeño fragmento de código simple, para ilustrar la diferencia. Pruébelo con cada uno de los valores de verdadero y falso en 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, los procesos de daemon en UNIX eran aquellos que se ejecutaban constantemente en segundo plano, al igual que los servicios en Windows.

Un hilo de daemon en Java es uno que no impide que la JVM salga. Específicamente, la JVM se cerrará cuando solo queden hilos de daemon. Puede crear uno llamando al setDaemon()método Thread.

Echa un vistazo a los hilos de Daemon .

Los subprocesos de daemon son como proveedores de servicios para otros subprocesos u objetos que se ejecutan en el mismo proceso que el subproceso de daemon. Los subprocesos de daemon se utilizan para tareas de soporte en segundo plano y solo se necesitan mientras se ejecutan subprocesos normales. Si los subprocesos normales no se están ejecutando y los subprocesos restantes son subprocesos de daemon, el intérprete se cierra.

Por ejemplo, el navegador HotJava utiliza hasta cuatro hilos de daemon llamados "Image Fetcher" para obtener imágenes del sistema de archivos o la red para cualquier hilo que lo necesite.

Los subprocesos de daemon generalmente se utilizan para realizar servicios para su aplicación / applet (como cargar los "bits fiddley"). La diferencia principal entre los hilos de usuario y los hilos de demonio es que la JVM solo cerrará un programa cuando todos los hilos de usuario hayan terminado. La JVM finaliza los subprocesos de daemon cuando ya no hay subprocesos de usuario en ejecución, incluido el subproceso principal de ejecución.

setDaemon (verdadero / falso)? Este método se utiliza para especificar que un hilo es hilo de demonio.

public boolean isDaemon ()? Este método se utiliza para determinar si el hilo es hilo de demonio o no.

P.ej:

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

}

Salida:

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>

Definición de Daemon (Computación):

Un proceso en segundo plano que maneja las solicitudes de servicios, como la cola de impresión y las transferencias de archivos, y está inactivo cuando no es necesario.

—— Fuente: Inglés por Oxford Dictionaries

¿Qué es el hilo Daemon en Java?

• Los subprocesos de Daemon pueden cerrarse en cualquier momento entre su flujo. No Daemon, es decir, el subproceso de usuario se ejecuta por completo.
• Los subprocesos de daemon son subprocesos que se ejecutan de forma intermitente en segundo plano mientras se ejecutan otros subprocesos que no son de daemon.
• Cuando se completan todos los subprocesos no daemon, los subprocesos daemon finalizan automáticamente.
• Los hilos de daemon son proveedores de servicios para hilos de usuario que se ejecutan en el mismo proceso.
• A la JVM no le importan los subprocesos de daemon para completar cuando está en estado de Ejecución, ni siquiera finalmente el bloque también permite la ejecución. JVM da preferencia a los subprocesos que no son daemon creados por nosotros.
• Los hilos Daemon actúan como servicios en Windows.
• La JVM detiene los subprocesos de daemon cuando todos los subprocesos de usuario (en contraste con los subprocesos de daemon) finalizan. Por lo tanto, los subprocesos de daemon se pueden usar para implementar, por ejemplo, una funcionalidad de supervisión cuando JVM detiene el subproceso tan pronto como todos los subprocesos de usuario se han detenido.

Un subproceso de daemon es un subproceso que se considera que realiza algunas tareas en segundo plano, como el manejo de solicitudes o varios cronjobs que pueden existir en una aplicación.

Cuando su programa solo tenga hilos de demonio restantes, saldrá. Esto se debe a que, por lo general, estos subprocesos funcionan junto con subprocesos normales y proporcionan un manejo en segundo plano de los eventos.

Puede especificar que a Threades un demonio utilizando el setDaemonmétodo, generalmente no salen, ni se interrumpen ... simplemente se detienen cuando se detiene la aplicación.

Un error que me gustaría aclarar:

• Suponga que si el hilo del demonio (por ejemplo B) se crea dentro del hilo del usuario (por ejemplo, A); luego, el final de este hilo de usuario / hilo primario (A) no terminará el hilo de demonio / hilo secundario (B) que ha creado; El hilo de usuario proporcionado es el único que se está ejecutando actualmente.
• Por lo tanto, no hay una relación padre-hijo al final del hilo. Todos los subprocesos de daemon (independientemente de dónde se cree) finalizarán una vez que no haya un único subproceso de usuario en vivo y eso haga que JVM finalice.
• Incluso esto es cierto para ambos (padre / hijo) son hilos de demonio.
• Si un subproceso hijo creado a partir de un subproceso de demonio, entonces ese también es un subproceso de daemon. Esto no necesitará ninguna configuración explícita de marca de hilo de demonio. De manera similar, si un subproceso secundario creado a partir de un subproceso de usuario también es un subproceso de usuario, si desea cambiarlo, entonces se necesita una configuración explícita del indicador de demonio antes de comenzar ese subproceso secundario.

Daemon Thread y User Threads. En general, todos los hilos creados por el programador son hilos de usuario (a menos que especifique que sean daemon o que su hilo padre sea un hilo de daemon). El hilo de usuario generalmente está destinado a ejecutar nuestro código de programa. JVM no termina a menos que todos los hilos del usuario terminen.

Java tiene un tipo especial de hilo llamado hilo de demonio .

• Muy baja prioridad.
• Solo se ejecuta cuando no se está ejecutando ningún otro subproceso del mismo programa.
• JVM finaliza el programa terminando estos subprocesos, cuando los subprocesos de daemon son los únicos subprocesos que se ejecutan en un programa.

¿Para qué se usan los hilos de daemon?

Normalmente se utiliza como proveedores de servicios para subprocesos normales. Por lo general, tiene un bucle infinito que espera la solicitud de servicio o realiza las tareas del subproceso. No pueden hacer trabajos importantes. (Porque no sabemos cuándo tendrán tiempo de CPU y pueden terminar en cualquier momento si no hay otros subprocesos en ejecución).

Un ejemplo típico de este tipo de hilos es el recolector de basura de Java .

Hay más...

• Solo llamas al setDaemon() método antes de llamar al start()método. Una vez que el hilo se está ejecutando, no puede modificar su estado de demonio.
• Use el isDaemon()método para verificar si un hilo es un hilo demonio o un hilo usuario.

Los hilos de demonio son como asistentes. Los subprocesos que no son Daemon son como artistas de primera línea. Los asistentes ayudan a los artistas a completar un trabajo. Cuando se completa el trabajo, los artistas no necesitan ayuda para realizar más. Como no se necesita ayuda, los asistentes abandonan el lugar. Entonces, cuando el trabajo de los hilos no Daemon termina, los hilos Daemon se marchan.

El subproceso de daemon es como un subproceso normal, excepto que la JVM solo se cerrará cuando los otros subprocesos no daemon no existan. Los subprocesos de daemon generalmente se usan para realizar servicios para su aplicación.

Los subprocesos de daemon en Java son aquellos subprocesos que se ejecutan en segundo plano y creados principalmente por JVM para realizar tareas en segundo plano como la recolección de basura y otras tareas de mantenimiento.

Puntos a tener en cuenta:

1. Cualquier subproceso creado por el subproceso principal, que ejecuta el método principal en Java, por defecto no es un demonio porque el subproceso hereda su naturaleza demoníaca del subproceso que lo crea, es decir, el subproceso principal y dado que el subproceso principal es un subproceso no daemon, cualquier otro subproceso creado a partir de él permanecerá como no demonio hasta que se convierta explícitamente en demonio llamando a setDaemon (verdadero).

2. Thread.setDaemon (true) crea un demonio Thread pero solo se puede invocar antes de iniciar Thread en Java. Lanzará IllegalThreadStateException si el subproceso correspondiente ya está iniciado y ejecutándose.

Diferencia entre Daemon y no Daemon thread en Java:

1) JVM no espera a que finalice ningún subproceso de daemon antes de existir.

2) Daemon Thread se tratan de manera diferente que User Thread cuando JVM termina, finalmente no se llaman bloques, las pilas no se desenrollan y JVM simplemente sale.

En Java, los subprocesos de Daemon son uno de los tipos de subprocesos que no impiden la salida de Java Virtual Machine (JVM). El objetivo principal de un subproceso de daemon es ejecutar una tarea en segundo plano, especialmente en el caso de alguna tarea o trabajo periódico de rutina. Con las salidas JVM, el hilo del demonio también muere.

Al establecer a thread.setDaemon(true), un hilo se convierte en un hilo de demonio. Sin embargo, solo puede establecer este valor antes de que comience el hilo.

Aquí hay un ejemplo para probar el comportamiento de subprocesos de daemon en caso de salida de jvm debido a la inexistencia de subprocesos de usuario.

Tenga en cuenta la segunda última línea en la salida a continuación, cuando salió el hilo principal, el hilo del demonio también murió y no imprimió la declaración finalmente ejecutada9 dentro del bloque finalmente. Esto significa que los recursos de E / S cerrados dentro del bloque finalmente de un subproceso de daemon no se cerrarán si JVM sale debido a la inexistencia de subprocesos de usuario.

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

Salida

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

Los subprocesos de daemon son, como todos explicaron, no limitarán a JVM a salir, por lo que básicamente es un subproceso feliz para la aplicación desde el punto de vista de la salida.

Quiero agregar que los subprocesos de daemon se pueden usar cuando digo que estoy proporcionando una API como enviar datos a un servidor de terceros / o JMS, es posible que necesite agregar datos al nivel de JVM del cliente y luego enviarlos a JMS en un subproceso separado. Puedo hacer este hilo como hilo de demonio, si este no es un dato obligatorio para ser enviado al servidor. Este tipo de datos es como la inserción / agregación de registros.

Saludos Manish

El subproceso de daemon es como el proceso de daemon que se encarga de administrar los recursos, Java VM crea un subproceso de daemon para servir a los subprocesos del usuario. ejemplo de sistema de actualización para unix, unix es un proceso demonio. El subproceso hijo de daemon siempre es subproceso de daemon, por lo que, de forma predeterminada, daemon es falso. Puede comprobar el subproceso como daemon o usuario mediante el método "isDaemon ()". por lo tanto, el hilo de daemon o el proceso de daemon son básicamente responsables de administrar los recursos. por ejemplo, cuando inicia jvm, se está ejecutando un recolector de basura que es un subproceso de daemon cuya prioridad es 1, que es la más baja, que administra la memoria. jvm está vivo mientras el hilo del usuario esté vivo, no se puede matar el hilo del demonio. jvm es responsable de matar los hilos del demonio.

Hablemos solo en código con ejemplos de trabajo. Me gusta la respuesta de russ arriba, pero para eliminar cualquier duda que tuviera, la mejoré un poco. Lo ejecuté dos veces, una vez con el subproceso de trabajo establecido en deamon verdadero (subproceso deamon) y otra vez establecido en falso (subproceso de usuario). Confirma que el hilo del demonio termina cuando termina el hilo principal.

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

Los subprocesos de daemon se conocen generalmente como subprocesos de "proveedor de servicios". Estos hilos no deben usarse para ejecutar el código del programa sino el código del sistema. Estos subprocesos se ejecutan en paralelo a su código, pero JVM puede matarlos en cualquier momento. Cuando JVM no encuentra hilos de usuario, lo detiene y todos los hilos de demonio terminan instantáneamente. Podemos establecer un hilo que no sea daemon en daemon usando:

setDaemon(true)

Los subprocesos de daemon son subprocesos que se ejecutan en segundo plano siempre que otros subprocesos no daemon del proceso todavía se estén ejecutando. Por lo tanto, cuando se completan todos los subprocesos no daemon, los subprocesos daemon se terminan. Un ejemplo para el hilo que no es daemon es el hilo que ejecuta Main. Un hilo se hace demonio llamando alsetDaemon() método antes de que se inicie el hilo

Para más referencia: hilo Daemon en Java

Para mí, el hilo del demonio es como el encargado de la casa para los hilos de los usuarios. Si todos los hilos de usuario terminaron, el hilo de demonio no tiene trabajo y es eliminado por JVM. Lo expliqué en el video de YouTube .

JVM realizará el trabajo cuando se complete una última ejecución de subproceso que no sea daemon. Por defecto, JVM creará un hilo como no demonio, pero podemos hacer Thread como un demonio con ayuda del método setDaemon(true). Un buen ejemplo del hilo Daemon es el hilo GC que completará su trabajo tan pronto como se completen todos los hilos no demonios.

Los hilos de demonio mueren cuando sale el hilo del creador.

Los subprocesos no daemon (predeterminado) pueden incluso vivir más tiempo que el subproceso principal.

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