Ciclo de vida y estados de un hilo en C#

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

Diagrama de flujo:
 

Ciclo de vida de un hilo

1. Estado no iniciado: cuando se crea una instancia de una clase de subproceso, está en estado no iniciado, lo que significa que el subproceso aún no ha comenzado a ejecutarse cuando el subproceso está en este estado. O, en otras palabras , no se llama al método Start() .
    

Thread thr = new Thread(); 

1. Aquí, thr está en un estado no iniciado.
2. Estado ejecutable: un subproceso que está listo para ejecutarse se mueve al 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. O en otras palabras, se llama al método  Start() .
    
3. Estado de ejecución: un subproceso que se está ejecutando. O en otras palabras, el hilo obtiene el procesador.
4. Estado no ejecutable: un subproceso que no es ejecutable porque
   • Se llama al método Sleep().
   • Se llama al método Wait().
   • Debido a la solicitud de E/S.
   • Se llama al método Suspend().
5. Estado muerto: cuando el subproceso completa su tarea, el subproceso entra en estado muerto, termina, aborta.

Implementando estados de subprocesos en C#

En C#, para obtener el estado actual del subproceso, use la propiedad ThreadState o IsAlive proporcionada por la clase Thread.
Sintaxis:
 

public ThreadState ThreadState{ get; }

O
 

public bool IsAlive { get; }

La clase Thread proporciona diferentes tipos de métodos para implementar los estados de los hilos. 
 

• El método Sleep() se usa para suspender temporalmente la ejecución actual del subproceso durante milisegundos específicos, de modo que otros subprocesos puedan tener la oportunidad de iniciar la ejecución, o pueden obtener la CPU para la ejecución.
• El método Join() se utiliza para hacer que todo el subproceso de llamada espere hasta que el subproceso principal, es decir, el subproceso unido, complete su trabajo.
• El método Abort() se usa para abortar el hilo.
• Se llama al método Suspend() para suspender el hilo.
• Se llama al método Resume() para reanudar el hilo suspendido.
• El método Start() se usa para enviar un hilo a un estado ejecutable.

Ejemplo:
 

// C# program to illustrate the
// states of the thread
using System;
using System.Threading;
 
public class MyThread {
 
    // Non-Static method
    public void thread()
    {
        for (int x = 0; x < 2; x++) {
            Console.WriteLine("My Thread");
        }
    }
}
 
public class ThreadExample {
 
    // Main method
    public static void Main()
    {
 
        // Creating instance for
        // mythread() method
        MyThread obj = new MyThread();
 
        // Creating and initializing
        // threads Unstarted state
        Thread thr1 = new Thread(new ThreadStart(obj.thread));
 
        Console.WriteLine("ThreadState: {0}",
                          thr1.ThreadState);
 
        // Running state
        thr1.Start();
        Console.WriteLine("ThreadState: {0}",
                           thr1.ThreadState);
 
        // thr1 is in suspended state
        thr1.Suspend();
        Console.WriteLine("ThreadState: {0}",
                           thr1.ThreadState);
 
        // thr1 is resume to running state
        thr1.Resume();
        Console.WriteLine("ThreadState: {0}",
                          thr1.ThreadState);
    }
}

Producción: 
 

ThreadState: Unstarted
ThreadState: Running
ThreadState: SuspendRequested
ThreadState: Running
My Thread
My Thread

Explicación: El ejemplo anterior muestra los diferentes estados del subproceso thr1 . Estos estados de un subproceso thr1 se determinan utilizando la propiedad ThreadState de la clase Thread. Además, usamos los métodos Suspend() y Resume() para suspender la ejecución actual del hilo y reanudar el hilo suspendido usando el método Resume .