Ciclo de vida y estados de un hilo en Java

Un subproceso en Java en cualquier momento existe en cualquiera de los siguientes estados. Un hilo se encuentra solo en uno de los estados mostrados en cualquier instante: 

1. Nuevo
2. Ejecutable
3. Obstruido
4. Esperando
5. Espera cronometrada
6. Terminado

El diagrama que se muestra a continuación representa varios estados de un hilo en cualquier instante de tiempo.

Ciclo de vida de un hilo

1. Nuevo hilo: cuando se crea un nuevo hilo, está en el nuevo estado. El subproceso aún no ha comenzado a ejecutarse cuando el subproceso está en este estado. Cuando un subproceso se encuentra en el nuevo estado, su código aún no se ha ejecutado y no ha comenzado a ejecutarse.
2. Estado ejecutable: un subproceso que está listo para ejecutarse se mueve a un estado ejecutable. En este estado, un subproceso podría estar ejecutándose o podría estar listo para ejecutarse en cualquier momento. Es responsabilidad del programador de subprocesos darle al subproceso tiempo para ejecutarse. 
   Un programa de subprocesos múltiples asigna una cantidad fija de tiempo a cada subproceso individual. Todos y cada uno de los subprocesos se ejecutan durante un breve período de tiempo y luego se detienen y ceden la CPU a otro subproceso para que otros subprocesos puedan tener la oportunidad de ejecutarse. Cuando esto sucede, todos los subprocesos que están listos para ejecutarse, esperando a que la CPU y el subproceso en ejecución actual se encuentren en un estado ejecutable.
3. Estado bloqueado/en espera: cuando un subproceso está temporalmente inactivo, se encuentra en uno de los siguientes estados: 
   • Obstruido
   • Esperando
4. Espera temporizada: un subproceso se encuentra en un estado de espera temporizado cuando llama a un método con un parámetro de tiempo de espera. Un subproceso permanece en este estado hasta que se completa el tiempo de espera o hasta que se recibe una notificación. Por ejemplo, cuando un subproceso llama a suspensión o espera condicional, se mueve a un estado de espera cronometrado.
5. Estado terminado: un subproceso termina debido a cualquiera de las siguientes razones: 
   • Porque sale normalmente. Esto sucede cuando el programa ha ejecutado completamente el código del hilo.
   • Porque ocurrió algún evento erróneo inusual, como una falla de segmentación o una excepción no controlada.

Implementando los estados de subprocesos en Java

En Java, para obtener el estado actual del hilo, use el método Thread.getState() para obtener el estado actual del hilo. Java proporciona la clase java.lang.Thread.State que define las constantes ENUM para el estado de un hilo, cuyo resumen se muestra a continuación: 

1. Nuevo 

Declaration: public static final Thread.State NEW

Descripción: estado del hilo para un hilo que aún no ha comenzado. 

2. Ejecutable 

Declaration: public static final Thread.State RUNNABLE

Descripción: estado de subproceso para un subproceso ejecutable. Un subproceso en estado ejecutable se está ejecutando en la máquina virtual de Java, pero puede estar esperando otros recursos del sistema operativo, como un procesador. 

3. Bloqueado 

Declaration: public static final Thread.State BLOCKED

Descripción: estado de subproceso para un subproceso bloqueado esperando un bloqueo de monitor. Un subproceso en el estado bloqueado está esperando un bloqueo de monitor para ingresar a un bloque/método sincronizado o volver a ingresar a un bloque/método sincronizado después de llamar a Object.wait(). 

4. Esperando 

Declaration: public static final Thread.State WAITING

Descripción: estado de subproceso para un subproceso en espera. Estado de subproceso para un subproceso en espera. Un subproceso está en estado de espera debido a la llamada a uno de los siguientes métodos: 

• Object.wait sin tiempo de espera
• Thread.join sin tiempo de espera
• LockSupport.parque

5. Tiempo de espera 

Declaration: public static final Thread.State TIMED_WAITING

Descripción: estado de subproceso para un subproceso en espera con un tiempo de espera especificado. Un subproceso está en el estado de espera cronometrado debido a la llamada a uno de los siguientes métodos con un tiempo de espera positivo especificado: 

• Subproceso.dormir
• Object.wait con tiempo de espera
• Thread.join con tiempo de espera
• LockSupport.parkNanos
• LockSupport.parkHasta

6. Terminado 

Declaration: public static final Thread.State TERMINATED

Descripción: estado de subproceso para un subproceso terminado. El subproceso ha completado la ejecución. 

// Java program to demonstrate thread states
class thread implements Runnable {
    public void run()
    {
        // moving thread2 to timed waiting state
        try {
            Thread.sleep(1500);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
 
        System.out.println(
            "State of thread1 while it called join() method on thread2 -"
            + Test.thread1.getState());
        try {
            Thread.sleep(200);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
 
public class Test implements Runnable {
    public static Thread thread1;
    public static Test obj;
 
    public static void main(String[] args)
    {
        obj = new Test();
        thread1 = new Thread(obj);
 
        // thread1 created and is currently in the NEW
        // state.
        System.out.println(
            "State of thread1 after creating it - "
            + thread1.getState());
        thread1.start();
 
        // thread1 moved to Runnable state
        System.out.println(
            "State of thread1 after calling .start() method on it - "
            + thread1.getState());
    }
 
    public void run()
    {
        thread myThread = new thread();
        Thread thread2 = new Thread(myThread);
 
        // thread1 created and is currently in the NEW
        // state.
        System.out.println(
            "State of thread2 after creating it - "
            + thread2.getState());
        thread2.start();
 
        // thread2 moved to Runnable state
        System.out.println(
            "State of thread2 after calling .start() method on it - "
            + thread2.getState());
 
        // moving thread1 to timed waiting state
        try {
            // moving thread1 to timed waiting state
            Thread.sleep(200);
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(
            "State of thread2 after calling .sleep() method on it - "
            + thread2.getState());
 
        try {
            // waiting for thread2 to die
            thread2.join();
        }
        catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(
            "State of thread2 when it has finished it's execution - "
            + thread2.getState());
    }
}

State of thread1 after creating it - NEW
State of thread1 after calling .start() method on it - RUNNABLE
State of thread2 after creating it - NEW
State of thread2 after calling .start() method on it - RUNNABLE
State of thread2 after calling .sleep() method on it - TIMED_WAITING
State of thread1 while it called join() method on thread2 -WAITING
State of thread2 when it has finished it's execution - TERMINATED

Explicación: cuando se crea un hilo nuevo, el hilo está en el estado NUEVO. Cuando se llama al método start() en un subproceso, el programador de subprocesos lo mueve al estado Runnable. Cada vez que se llama al método join() en una instancia de subproceso, el subproceso actual que ejecuta esa declaración esperará a que este subproceso pase al estado Terminado. Entonces, antes de que la declaración final se imprima en la consola, el programa llama a join() en el subproceso2, lo que hace que el subproceso1 espere mientras el subproceso2 completa su ejecución y pasa al estado Terminado. thread1 pasa al estado de espera porque está esperando que thread2 complete su ejecución, ya que ha llamado a join en thread2.

Este artículo es una contribución de Mayank Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.