ThreadPriority Énumération

Définition

Espace de noms:

System.Threading

Assemblys:

netstandard.dll, System.Threading.Thread.dll

Source:

ThreadPriority.cs

Spécifie la priorité de planification d’un Thread.

public enum class ThreadPriority

public enum ThreadPriority

type ThreadPriority = 

Public Enum ThreadPriority

Héritage

Object

ValueType

Enum

ThreadPriority

Champs

Nom	Valeur	Description
Lowest	0	Il Thread peut être planifié après les threads avec n’importe quelle autre priorité.
BelowNormal	1	Il Thread peut être planifié après les threads avec Normal priorité et avant ceux avec Lowest priorité.
Normal	2	Il Thread peut être planifié après les threads avec AboveNormal priorité et avant ceux avec BelowNormal priorité. Les threads ont Normal la priorité par défaut.
AboveNormal	3	Il Thread peut être planifié après les threads avec Highest priorité et avant ceux avec Normal priorité.
Highest	4	Les Thread threads peuvent être planifiés avant toute autre priorité.

Exemples

L’exemple de code suivant montre le résultat de la modification de la priorité d’un thread. Trois threads sont créés, la priorité d’un thread est définie sur BelowNormal et la priorité d’une seconde est définie sur AboveNormal. Chaque thread incrémente une variable dans une while boucle et s’exécute pour une heure définie.

using System;
using System.Threading;
using Timers = System.Timers;

class Test
{
    static void Main()
    {
        PriorityTest priorityTest = new PriorityTest();

        Thread thread1 = new Thread(priorityTest.ThreadMethod);
        thread1.Name = "ThreadOne";
        Thread thread2 = new Thread(priorityTest.ThreadMethod);
        thread2.Name = "ThreadTwo";
        thread2.Priority = ThreadPriority.BelowNormal;
        Thread thread3 = new Thread(priorityTest.ThreadMethod);
        thread3.Name = "ThreadThree";
        thread3.Priority = ThreadPriority.AboveNormal;

        thread1.Start();
        thread2.Start();
        thread3.Start();
        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.LoopSwitch = false;
    }
}

class PriorityTest
{
    static volatile bool loopSwitch;
    [ThreadStatic] static long threadCount = 0;

    public PriorityTest()
    {
        loopSwitch = true;
    }

    public bool LoopSwitch
    {
        set{ loopSwitch = value; }
    }

    public void ThreadMethod()
    {
        while(loopSwitch)
        {
            threadCount++;
        }
        Console.WriteLine("{0,-11} with {1,11} priority " +
            "has a count = {2,13}", Thread.CurrentThread.Name, 
            Thread.CurrentThread.Priority.ToString(), 
            threadCount.ToString("N0")); 
    }
}
// The example displays output like the following:
//    ThreadOne   with      Normal priority has a count =   755,897,581
//    ThreadThree with AboveNormal priority has a count =   778,099,094
//    ThreadTwo   with BelowNormal priority has a count =     7,840,984

Imports System.Threading
Imports Timers = System.Timers

Public Module Example
   Dim t As Timers.Timer
   Private priorityTest As New PriorityTest()

    Public Sub Main()
        Dim thread1 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread1.Name = "ThreadOne"
        Dim thread2 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread2.Name = "ThreadTwo"
        thread2.Priority = ThreadPriority.BelowNormal
        Dim thread3 As New Thread(AddressOf priorityTest.ThreadMethod)
        thread3.Name = "ThreadThree"
        thread3.Priority = ThreadPriority.AboveNormal
        thread1.Start()
        thread2.Start()
        thread3.Start()

        ' Allow threads to execute for about 10 seconds.
        t = New Timers.Timer()
        t.AutoReset = False
        t.Interval = 10000
        AddHandler t.Elapsed, AddressOf Elapsed
        t.Start()
    End Sub

    Private Sub Elapsed(sender As Object, e As Timers.ElapsedEventArgs)
       priorityTest.LoopSwitch = False
    End Sub
End Module

Public Class PriorityTest
    Private Shared loopSwitchValue As Boolean
    <ThreadStatic> Shared threadCount As Long

    Sub New()
        loopSwitchValue = True
    End Sub

    WriteOnly Property LoopSwitch As Boolean
        Set
            loopSwitchValue = Value
        End Set
    End Property

    Sub ThreadMethod()
        Do While True
            threadCount += 1
            If Not loopSwitchValue Then Exit Do
        Loop

        Console.WriteLine("{0,-11} with {1,11} priority " &
            "has a count = {2,13}", Thread.CurrentThread.Name,
            Thread.CurrentThread.Priority.ToString(),
            threadCount.ToString("N0")) 
    End Sub
End Class
' The example displays the following output:
'    ThreadOne   with      Normal priority has a count =   755,897,581
'    ThreadThree with AboveNormal priority has a count =   778,099,094
'    ThreadTwo   with BelowNormal priority has a count =     7,840,984

Remarques

ThreadPriority définit l’ensemble de toutes les valeurs possibles pour une priorité de thread. Les priorités de thread spécifient la priorité relative d’un thread par rapport à une autre.

Chaque thread a une priorité affectée. Les threads créés dans le runtime reçoivent initialement la Normal priorité, tandis que les threads créés en dehors du runtime conservent leur priorité précédente lorsqu’ils entrent dans le runtime. Vous pouvez obtenir et définir la priorité d’un thread en accédant à sa Priority propriété.

Les threads sont planifiés pour être exécutés selon leur priorité. L’algorithme de planification utilisé pour déterminer l’ordre d’exécution des threads varie selon chaque système d’exploitation. Le système d’exploitation peut également ajuster la priorité de thread dynamiquement à mesure que le focus de l’interface utilisateur est déplacé entre le premier plan et l’arrière-plan.

La priorité d’un thread n’affecte pas l’état du thread ; l’état du thread doit être Running avant que le système d’exploitation puisse le planifier.

Voir aussi

• Thread
• Planification des threads