ThreadPriority Énumération

Référence

Définition

Espace de noms:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Spécifie la priorité de planification de Thread.

public enum class ThreadPriority

public enum ThreadPriority

[System.Serializable]
public enum ThreadPriority

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadPriority

type ThreadPriority =

[<System.Serializable>]
type ThreadPriority =

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadPriority =

Public Enum ThreadPriority

Héritage: Object

ValueType

Enum
ThreadPriority

Attributs: SerializableAttribute ComVisibleAttribute

Champs

AboveNormal	3	Il est possible de planifier Thread après les threads de priorité `Highest` et avant les threads de priorité `Normal`.
BelowNormal	1	Il est possible de planifier Thread après les threads de priorité `Normal` et avant les threads de priorité `Lowest`.
Highest	4	Il est possible de planifier Thread avant les threads de toute autre priorité.
Lowest	0	Il est possible de planifier Thread après les threads de toute autre priorité.
Normal	2	Il est possible de planifier Thread après les threads de priorité `AboveNormal` et avant les threads de priorité `BelowNormal`. Par défaut, les threads ont une priorité `Normal`.

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’un second est définie sur AboveNormal. Chaque thread incrémente une variable dans une while boucle et s’exécute pendant une durée 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 à un 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 du thread varie selon chaque système d’exploitation. Le système d’exploitation peut également ajuster dynamiquement la priorité du thread lorsque 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.

S’applique à