ThreadPriority Énumération
Définition
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 ThreadPrioritypublic enum ThreadPriority[System.Serializable]
public enum ThreadPriority[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadPrioritytype ThreadPriority = [<System.Serializable>]
type ThreadPriority = [<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadPriority = Public Enum ThreadPriority- Héritage
- Attributs
Champs
| AboveNormal | 3 | Il est possible de planifier Thread après les threads de priorité |
| BelowNormal | 1 | Il est possible de planifier Thread après les threads de priorité |
| 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é |
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.