ThreadPriority Enum

Definition

Spécifie la priorité de planification de Thread.Specifies the scheduling priority of a Thread.

public enum class ThreadPriority
public enum ThreadPriority
[System.Serializable]
public enum ThreadPriority
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum ThreadPriority
type ThreadPriority = 
Public Enum ThreadPriority
Inheritance
ThreadPriority
Attributes

Fields

AboveNormal 3

Il est possible de planifier Thread après les threads de priorité Highest et avant les threads de priorité Normal.The Thread can be scheduled after threads with Highest priority and before those with Normal priority.

BelowNormal 1

Il est possible de planifier Thread après les threads de priorité Normal et avant les threads de priorité Lowest.The Thread can be scheduled after threads with Normal priority and before those with Lowest priority.

Highest 4

Il est possible de planifier Thread avant les threads de toute autre priorité.The Thread can be scheduled before threads with any other priority.

Lowest 0

Il est possible de planifier Thread après les threads de toute autre priorité.The Thread can be scheduled after threads with any other priority.

Normal 2

Il est possible de planifier Thread après les threads de priorité AboveNormal et avant les threads de priorité BelowNormal.The Thread can be scheduled after threads with AboveNormal priority and before those with BelowNormal priority. Par défaut, les threads ont une priorité Normal.Threads have Normal priority by default.

Examples

L’exemple de code suivant montre le résultat de la modification de la priorité d’un thread.The following code example shows the result of changing the priority of a 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.Three threads are created, the priority of one thread is set to BelowNormal, and the priority of a second is set to AboveNormal. Chaque thread incrémente une variable dans une boucle while et s’exécute pendant une période définie.Each thread increments a variable in a while loop and runs for a set time.

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 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

Remarks

ThreadPriority définit l’ensemble de toutes les valeurs possibles pour une priorité de thread.ThreadPriority defines the set of all possible values for a thread priority. Les priorités de thread spécifient la priorité relative d’un thread par rapport à un autre.Thread priorities specify the relative priority of one thread versus another.

Chaque thread a une priorité affectée.Every thread has an assigned priority. Les threads créés dans le runtime reçoivent initialement la priorité Normal, tandis que les threads créés en dehors du runtime conservent leur priorité précédente lorsqu’ils entrent dans le Runtime.Threads created within the runtime are initially assigned the Normal priority, while threads created outside the runtime retain their previous priority when they enter the runtime. Vous pouvez obtenir et définir la priorité d’un thread en accédant à sa propriété Priority.You can get and set the priority of a thread by accessing its Priority property.

Les threads sont planifiés pour être exécutés selon leur priorité.Threads are scheduled for execution based on their priority. L’algorithme de planification utilisé pour déterminer l’ordre d’exécution des threads varie en fonction de chaque système d’exploitation.The scheduling algorithm used to determine the order of thread execution varies with each operating system. Le système d’exploitation peut également ajuster la priorité de thread dynamiquement lorsque le focus de l’interface utilisateur est déplacé entre le premier plan et l’arrière-plan.The operating system can also adjust the thread priority dynamically as the user interface's focus is moved between the foreground and the background.

La priorité d’un thread n’affecte pas l’état du thread. l’état du thread doit être Running pour que le système d’exploitation puisse le planifier.The priority of a thread does not affect the thread's state; the state of the thread must be Running before the operating system can schedule it.

Applies to

See also