tutorialspoint threads thread que multi manage implement example java multithreading

threads - runnable java



¿Qué es un hilo demonio en Java? (24)

Definición de Daemon (Informática):

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. Source

¿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 completamente.
  • Los hilos de Daemon se ejecutan con una prioridad baja.
  • Los subprocesos de daemon son subprocesos que se ejecutan de forma intermitente en segundo plano siempre que se estén ejecutando otros subprocesos que no sean de daemon.
  • Cuando se completan todos los subprocesos que no son del daemon, los subprocesos del daemon terminan automáticamente.
  • Las hebras de Daemon son proveedores de servicios para las hebras de usuario que se ejecutan en el mismo proceso.
  • A la JVM no le importa que los hilos del demonio se completen cuando están en estado de Ejecución, ni siquiera finalmente bloquear, también dejar que se ejecute. JVM da preferencia a los hilos no daemon creados por nosotros.
  • Los hilos de Daemon actúan como servicios en Windows.
  • La JVM detiene los subprocesos del daemon cuando se terminan todos los subprocesos de usuario (en contraste con los subprocesos del daemon). Por lo tanto, los subprocesos del daemon se pueden utilizar para implementar, por ejemplo, una funcionalidad de supervisión, ya que la JVM detiene el subproceso tan pronto como todos los subprocesos del usuario se han detenido.

¿Alguien puede decirme qué hilos de daemon están en Java?

Algunos puntos más (Referencia: Concurrencia Java en la práctica ).

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

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

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

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

Aquí hay un ejemplo para probar el comportamiento de los hilos del daemon en el caso de la salida jvm debido a la no existencia de hilos de usuario.

Tenga en cuenta la segunda última línea en la salida a continuación, cuando se cerró el subproceso principal, el subproceso del demonio también se murió y no se imprimió la declaración finalmente ejecutada9 dentro del bloque finalmente. Esto significa que cualquier recurso de E / S cerrado dentro del bloque finalmente de un subproceso del daemon no se cerrará si JVM sale debido a la no existencia 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

Daemon Thread y User Threads. En general, todos los subprocesos creados por el programador son subprocesos de usuario (a menos que especifique que sea un demonio o su subproceso principal sea un subproceso de demonio). Los hilos de usuario generalmente están destinados a ejecutar nuestro código de programación. JVM no termina a menos que todos los subprocesos del usuario terminen.

El hilo del daemon es como el proceso del daemon, que es responsable de administrar los recursos; la máquina virtual de Java crea un hilo del daemon para servir a los hilos del usuario. Ejemplo de sistema de actualización para unix, unix es un proceso de daemon. El elemento secundario del hilo del daemon es siempre el hilo del daemon, por lo que el daemon predeterminado es false. Puede verificar el hilo como daemon o usuario utilizando el método "isDaemon ()". por lo tanto, el proceso del hilo o del daemon del daemon son básicamente responsables de administrar los recursos. por ejemplo, cuando inicia jvm, hay un recolector de basura en ejecución que es un subproceso del daemon cuya prioridad es 1 que es la más baja, que es administrar la memoria. jvm está vivo siempre que el hilo del usuario esté vivo, u no puede matar el daemon thread.jvm es responsable de matar los hilos del daemon.

El subproceso del daemon es como un subproceso normal, excepto que la JVM solo se apagará cuando los otros subprocesos que no sean del demonio no existan. Los hilos de Daemon se utilizan normalmente para realizar servicios para su aplicación.

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

Al establecer un thread.setDaemon(true) , un hilo se convierte en un hilo demonio. Sin embargo, solo puede establecer este valor antes del inicio del hilo.

Hablemos solo en código con ejemplos de trabajo. Me gusta la respuesta de Russ de arriba, pero para eliminar cualquier duda que haya tenido, la he mejorado un poco. Lo ejecuté dos veces, una vez con el subproceso de trabajo establecido en deamon true (hilo de deamon) y otra vez lo puse en false (hilo de usuario). Confirma que el hilo del deamon termina cuando el hilo 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

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

Java tiene un tipo especial de hilo llamado hilo daemon .

  • Muy baja prioridad.
  • Solo se ejecuta cuando no se está ejecutando ningún otro hilo del mismo programa.
  • JVM finaliza el programa terminando estos subprocesos, cuando los subprocesos del 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, tienen un bucle infinito que espera la solicitud de servicio o realiza las tareas del hilo. No pueden hacer trabajos importantes. (Porque no sabemos cuándo van a tener tiempo de CPU y pueden finalizar 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 llama al método setDaemon() antes de llamar al método start() . Una vez que el hilo se está ejecutando, no puede modificar el estado de su daemon.
  • Use el método isDaemon() para verificar si un subproceso es un subproceso de demonio o un subproceso de usuario.

Los hilos de Daemon en Java son aquellos que se ejecutan en segundo plano y que en su mayoría son creados por JVM para realizar tareas en segundo plano como la recolección de basura y otras tareas de mantenimiento de la casa.

Puntos a tener en cuenta:

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

  2. Thread.setDaemon (true) crea un daemon Thread pero solo se puede llamar antes de iniciar Thread en Java. Lanzará la excepción IllegalThreadStateException si el subproceso correspondiente ya está iniciado y en ejecución.

Diferencia entre los hilos Daemon y Non Daemon en Java:

1) JVM no espera a que termine el subproceso del daemon antes de existir.

2) Daemon Thread se trata de manera diferente a User Thread cuando JVM termina, finalmente los bloques no se llaman, las Stacks no están desconectadas y JVM simplemente sale.

Los hilos de Daemon se conocen generalmente como hilos "Proveedor de servicios". Estos subprocesos no deben utilizarse para ejecutar código de programa sino código de 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 daemon terminan instantáneamente. Podemos establecer un hilo no daemon a daemon usando:

setDaemon(true)

Los hilos de Daemon son, como todos explicaron, no limitarán la salida de JVM, así que básicamente es un hilo feliz para la aplicación desde el punto de vista de salida.

Quiero agregar que se pueden usar los hilos del daemon cuando diga que estoy proporcionando una API como enviar datos a un servidor de terceros o JMS, es posible que necesite agregar datos en el nivel de JVM del cliente y luego enviarlos a JMS en un hilo diferente. Puedo hacer este hilo como un hilo daemon, si esto 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

Los hilos del daemon mueren cuando el hilo del creador sale.

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

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

Los hilos del demonio son como asistentes. Los hilos que no son de Daemon son como los artistas frontales. Los asistentes ayudan a los artistas a completar un trabajo. Cuando se completa el trabajo, los artistas ya no necesitan ayuda para desempeñarse. Como no se necesita ayuda, los asistentes abandonan el lugar. Así que cuando los trabajos de los subprocesos que no son de Daemon han terminado, los subprocesos de Daemon se alejan.

Los subprocesos de daemon son subprocesos que se ejecutan en segundo plano siempre que se sigan ejecutando otros subprocesos que no son de demonio del proceso. Por lo tanto, cuando todos los subprocesos que no son de demonio se completan, los subprocesos de demonio se terminan. Un ejemplo para el subproceso no daemon es el subproceso que ejecuta el Principal. Un subproceso se setDaemon() demonio llamando al método setDaemon() antes de iniciar el subproceso

Para más referencia: hilo de Daemon en Java

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

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

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

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

booleano público isDaemon ()? Este método se utiliza para determinar si el subproceso es un subproceso del daemon 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>

Para mí, el hilo del daemon es como un guardián de la casa para los hilos de usuario. Si todos los subprocesos de usuario terminaron, el subproceso del daemon no tiene trabajo y fue eliminado por JVM. Lo expliqué en el video de YouTube .

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

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

Tener una lectura de los hilos de Daemon .

Un subproceso de daemon es un subproceso que se considera que realiza algunas tareas en segundo plano como manejar solicitudes o varios chronjobs 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 los subprocesos normales y proporcionan un manejo de eventos en segundo plano.

Puede especificar que un Thread sea ​​un demonio utilizando el método setDaemon , normalmente no se setDaemon , ni se interrumpen ... simplemente se detienen cuando se detiene la aplicación.

Un error que me gustaría aclarar:

  • Supongamos que si el subproceso 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 del daemon / hilo secundario (B) que ha creado; el hilo de usuario proporcionado es el único actualmente en ejecución.
  • Así que no hay una relación padre-hijo en el final del hilo. Todos los subprocesos de daemon (independientemente de donde se creen) finalizarán una vez que no haya un único subproceso de usuario activo y eso haga que JVM finalice.
  • Incluso esto es cierto para ambos (padre / hijo) son hilos de daemon.
  • Si un subproceso secundario creado a partir de un subproceso de daemon, también es un subproceso de daemon. Esto no necesitará ninguna configuración explícita de marca de hilo de daemon. De manera similar, si un subproceso secundario se creó a partir de un subproceso de usuario, entonces ese también es un subproceso de usuario, si desea cambiarlo, entonces se necesita una configuración explícita de marca de demonio antes del inicio de ese subproceso secundario.

Un subproceso de daemon es un subproceso que no impide que la JVM salga cuando el programa finalice, 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) para cambiar las propiedades del daemon Thread antes de que comience el hilo.

Cualquier hilo de Java puede ser un hilo demonio.

Los subprocesos del daemon son proveedores de servicios para otros subprocesos que se ejecutan en el mismo proceso que el subproceso del daemon. Por ejemplo, el navegador HotJava usa hasta cuatro subprocesos de daemon llamados "Image Fetcher" para obtener imágenes del sistema de archivos o de la red para cualquier subproceso que lo necesite. El método run() para un subproceso de daemon es típicamente un bucle infinito que espera una solicitud de servicio. Cuando los únicos subprocesos que quedan en un proceso son subprocesos de daemon, el intérprete sale. Esto tiene sentido porque cuando solo quedan subprocesos de daemon, no hay otro subproceso para el que un subproceso de daemon pueda proporcionar un servicio.

Para especificar que un subproceso es un subproceso daemon, llame al método setDaemon con el argumento true. Para determinar si un hilo es un hilo daemon, use el método de isDaemon .

Espero que esto pueda ayudar !!!!!!