C# | Prioridad de subprocesos en subprocesos múltiples – Part 1

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