Saltar al contenido

Ciclo de vida de un hilo en Java

septiembre 24, 2021
life cycle of a thread

En Java, un hilo siempre existe en cualquiera de los siguientes estados. Estos estados son:

  1. Nuevo
  2. Activo
  3. Bloqueado / Esperando
  4. Espera temporizada
  5. Terminado

Explicación de diferentes estados de subprocesos

Nuevo: Siempre que se crea un nuevo hilo, siempre está en el nuevo estado. Para un hilo en el nuevo estado, el código aún no se ha ejecutado y, por lo tanto, no ha comenzado su ejecución.

Activo: Cuando un hilo invoca el método start (), se mueve del nuevo estado al estado activo. El estado activo contiene dos estados dentro de él: uno es ejecutabley el otro es corriendo.

  • Ejecutable: Un subproceso que está listo para ejecutarse se mueve luego al estado ejecutable. En el estado ejecutable, el subproceso puede estar ejecutándose o puede estar listo para ejecutarse en cualquier momento dado. Es deber del programador de subprocesos proporcionar el tiempo de ejecución del subproceso, es decir, mover el subproceso al estado de ejecución.
    Un programa que implementa subprocesos múltiples adquiere un intervalo de tiempo fijo para cada subproceso individual. Todos y cada uno de los subprocesos se ejecutan durante un breve período de tiempo y, cuando finaliza ese intervalo de tiempo asignado, el subproceso cede voluntariamente la CPU al otro subproceso, de modo que los otros subprocesos también pueden ejecutarse durante su intervalo de tiempo. Siempre que se produzca un escenario de este tipo, todos los subprocesos que estén dispuestos a ejecutarse, esperando su turno para ejecutarse, se encuentran en el estado ejecutable. En el estado ejecutable, hay una cola donde se encuentran los subprocesos.
  • Corriendo: Cuando el subproceso obtiene la CPU, se mueve del estado ejecutable al estado en ejecución. Generalmente, el cambio más común en el estado de un hilo es de ejecutable a ejecutable y de nuevo a ejecutable.

Bloqueado o en espera: Siempre que un hilo está inactivo durante un período de tiempo (no de forma permanente), el hilo está en el estado bloqueado o en el estado de espera.

Por ejemplo, un hilo (digamos que su nombre es A) puede querer imprimir algunos datos de la impresora. Sin embargo, al mismo tiempo, el otro hilo (digamos que su nombre es B) está usando la impresora para imprimir algunos datos. Por lo tanto, el hilo A tiene que esperar a que el hilo B utilice la impresora. Por tanto, el hilo A está en estado bloqueado. Un subproceso en el estado bloqueado no puede realizar ninguna ejecución y, por lo tanto, nunca consume ningún ciclo de la Unidad central de procesamiento (CPU). Por lo tanto, podemos decir que el subproceso A permanece inactivo hasta que el programador del subproceso reactiva el subproceso A, que está en estado de espera o bloqueado.

Cuando el hilo principal invoca el método join (), se dice que el hilo principal está en estado de espera. El subproceso principal luego espera a que los subprocesos secundarios completen sus tareas. Cuando los subprocesos secundarios completan su trabajo, se envía una notificación al subproceso principal, que nuevamente mueve el subproceso de espera al estado activo.

Si hay muchos subprocesos en estado de espera o bloqueados, entonces es el deber del programador de subprocesos determinar qué subproceso elegir y cuál rechazar, y el subproceso elegido tiene la oportunidad de ejecutarse.

Espera temporizada: A veces, esperar conduce a la inanición. Por ejemplo, un hilo (su nombre es A) ha entrado en la sección crítica de un código y no está dispuesto a salir de esa sección crítica. En tal escenario, otro hilo (su nombre es B) tiene que esperar una eternidad, lo que conduce a la inanición. Para evitar tal escenario, se le da un estado de espera temporizada al hilo B. Por lo tanto, el hilo permanece en el estado de espera durante un período de tiempo específico, y no para siempre. Un ejemplo real de espera temporizada es cuando invocamos el método sleep () en un hilo específico. El método sleep () pone el hilo en el estado de espera temporizada. Una vez que se agota el tiempo, el hilo se despierta y comienza su ejecución desde que se fue antes.

Terminado: Un hilo alcanza el estado de terminación por las siguientes razones:

  • Cuando un hilo ha terminado su trabajo, existe o termina normalmente.
  • Terminación anormal: Ocurre cuando ocurren algunos eventos inusuales, como una excepción no controlada o un error de segmentación.

Un hilo terminado significa que el hilo ya no está en el sistema. En otras palabras, el hilo está muerto y no hay forma de que uno pueda reaparecer (activo después de matar) el hilo muerto.

El siguiente diagrama muestra los diferentes estados involucrados en el ciclo de vida de un hilo.

Ciclo de vida del hilo de Java

Implementación de estados de subprocesos

En Java, uno puede obtener el estado actual de un hilo usando el Thread.getState () método. los java.lang.Thread.State La clase de Java proporciona las constantes ENUM para representar el estado de un hilo. Estas constantes son:

Representa el primer estado de un subproceso que es el estado NUEVO.

Representa el estado ejecutable. Significa que un subproceso está esperando en la cola para ejecutarse.

Representa el estado bloqueado. En este estado, el hilo está esperando adquirir un bloqueo.

Representa el estado de espera. Un hilo pasará a este estado cuando invoca el método Object.wait () o el método Thread.join () sin tiempo de espera. Un subproceso en estado de espera está esperando que otro subproceso complete su tarea.

Representa el estado de espera temporizado. La principal diferencia entre la espera y la espera programada es la limitación de tiempo. La espera no tiene una limitación de tiempo, mientras que la espera programada tiene una limitación de tiempo. Un subproceso que invoca el siguiente método alcanza el estado de espera temporizada.

  • dormir
  • unirse con el tiempo de espera
  • esperar con tiempo de espera
  • parqueHasta que
  • parkNanos

Representa el estado final de un hilo que está terminado o muerto. Un hilo terminado significa que ha completado su ejecución.

Programa Java para demostrar estados de subprocesos

El siguiente programa Java muestra algunos de los estados de un hilo definido anteriormente.

Nombre del archivo: ThreadState.java

Producción:

The state of thread t1 after spawning it - NEW
The state of thread t1 after invoking the method start() on it - RUNNABLE
The state of thread t2 after spawning it - NEW
the state of thread t2 after calling the method start() on it - RUNNABLE
The state of thread t1 while it invoked the method join() on thread t2 -TIMED_WAITING
The state of thread t2 after invoking the method sleep() on it - TIMED_WAITING
The state of thread t2 when it has completed it's execution - TERMINATED

Explicación: Siempre que generamos un nuevo hilo, ese hilo alcanza el nuevo estado. Cuando se invoca el método start () en un subproceso, el planificador de subprocesos mueve ese subproceso al estado ejecutable. Siempre que se invoca el método join () en cualquier instancia de subproceso, el subproceso actual que ejecuta esa declaración tiene que esperar a que este subproceso termine su ejecución, es decir, mover ese subproceso al estado terminado. Por lo tanto, antes de que se imprima la sentencia de impresión final en la consola, el programa invoca el método join () en el subproceso t2, haciendo que el subproceso t1 espere mientras el subproceso t2 finaliza su ejecución y, por lo tanto, el subproceso t2 llega al estado terminado o muerto. . El subproceso t1 pasa al estado de espera porque está esperando que el subproceso t2 finalice su ejecución, ya que ha invocado el método join () en el subproceso t2.


close