C# | Prioridad de subprocesos en subprocesos múltiples

En un entorno de subprocesos múltiples, cada subproceso tiene su propia prioridad. La prioridad de un subproceso muestra la frecuencia con la que un subproceso obtiene acceso a los recursos de la CPU. Cada vez que creamos un hilo en C#, siempre tiene asignada alguna prioridad.

Puntos importantes:

• Un programador puede asignar explícitamente prioridad a un hilo.
• La prioridad predeterminada de un subproceso es Normal .
• El sistema operativo no asigna la prioridad de los hilos.
• Si un subproceso ha alcanzado un estado final, como Aborted , esto dará como resultado ThreadStateException.
• Si el valor especificado para una operación de establecimiento no es un valor ThreadPriority válido , esto daráArgumentException
• No se garantiza que el subproceso cuya prioridad sea alta se ejecute primero y el subproceso cuya prioridad sea baja se ejecute después. Debido al cambio de contexto, el subproceso de mayor prioridad puede ejecutarse después del subproceso de menor prioridad.
• Cuando está asignando una prioridad a un hilo, debe tener cuidado, si no lo está haciendo con cuidado, puede sufrir una inanición de hilos .
• La prioridad del subproceso siempre dependerá de la prioridad del proceso o del contenedor principal, por lo que establecer la prioridad del subproceso en la más alta no corresponderá a la ejecución en tiempo real.

¿Cómo establecer y obtener la prioridad del hilo?

La propiedad Thread.Priority se usa para obtener o establecer un valor que indica la prioridad de programación de un hilo.

Sintaxis:

public ThreadPriority Priority{ get; set; }

Aquí, la enumeración ThreadPriority en el System.Threadingespacio de nombres es responsable de especificar la prioridad de programación de un subproceso y las prioridades son:

• Máxima: El valor de esta prioridad es 4.
• AboveNormal: El valor de esta prioridad es 3.
• Normal: El valor de esta prioridad es 2.
• BelowNormal: El valor de esta prioridad es 1.
• Mínima: El valor de esta prioridad es 0.

Valor de propiedad: uno de los valores de ThreadPriority. El valor predeterminado es Normal.

Excepciones:

• ThreadStateException: si el subproceso ha alcanzado un estado final, como Anulado.
• ArgumentException: si el valor especificado para una operación de establecimiento no es un valor de ThreadPriority válido.

Ejemplo 1:

// C# program to illustrate how to
// set and get the priority of threads
using System;
using System.Threading;
  
class GFG {
  
    // Main Method
    static public void Main()
    {
  
        // Creating and initializing threads
        Thread T1 = new Thread(work);
        Thread T2 = new Thread(work);
        Thread T3 = new Thread(work);
  
        // Set the priority of threads
        T2.Priority = ThreadPriority.Highest;
        T3.Priority = ThreadPriority.BelowNormal;
        T1.Start();
        T2.Start();
        T3.Start();
  
        // Display the priority of threads
        Console.WriteLine("The priority of T1 is: {0}",
                                          T1.Priority);
  
        Console.WriteLine("The priority of T2 is: {0}",
                                          T2.Priority);
  
        Console.WriteLine("The priority of T3 is: {0}",
                                          T3.Priority);
    }
  
    public static void work()
    {
  
        // Sleep for 1 second
        Thread.Sleep(1000);
    }
}

Producción:

The priority of T1 is: Normal
The priority of T2 is: Highest
The priority of T3 is: BelowNormal

Ejemplo 2:

// C# program to illustrate the
// Priority property of Thread class
using System;
using System.Threading;
  
class GFG {
  
    // Main Method
    static public void Main()
    {
  
        // Creating and initializing threads
        Thread T1 = new Thread(work1);
        Thread T2 = new Thread(work2);
  
        // Set the priority of threads
        // Here T2 thread executes first 
        // because the Priority of T2 is
        // highest as compare to T1 thread
        T1.Priority = ThreadPriority.Lowest;
        T2.Priority = ThreadPriority.Highest;
        T1.Start();
        T2.Start();
    }
    public static void work1()
    {
  
        Console.WriteLine("T1 thread is working..");
    }
    public static void work2()
    {
  
        Console.WriteLine("T2 thread is working..");
    }
}

Producción:

T2 thread is working..
T1 thread is working..

Referencia:

• https://docs.microsoft.com/en-us/dotnet/api/system.threading.thread.priority?view=netframework-4.7.2