ThreadPriority Enumerazione
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Consente di specificare la priorità di pianificazione di un 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- Ereditarietà
- Attributi
Campi
| AboveNormal | 3 | Thread può essere pianificato dopo i thread la cui priorità è |
| BelowNormal | 1 | Thread può essere pianificato dopo i thread la cui priorità è |
| Highest | 4 | Thread può essere pianificato prima dei thread con una qualsiasi priorità. |
| Lowest | 0 | Thread può essere pianificato dopo i thread con una qualsiasi priorità. |
| Normal | 2 | Thread può essere pianificato dopo i thread la cui priorità è |
Esempio
Nell'esempio di codice seguente viene illustrato il risultato della modifica della priorità di un thread. Vengono creati tre thread, la priorità di un thread è impostata su BelowNormal e la priorità di un secondo è impostata su AboveNormal. Ogni thread incrementa una variabile in un while ciclo ed esegue per un periodo di tempo impostato.
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
Commenti
ThreadPriority definisce il set di tutti i valori possibili per una priorità thread. Le priorità del thread specificano la priorità relativa di un thread rispetto a un'altra.
Ogni thread ha una priorità assegnata. I thread creati all'interno del runtime vengono inizialmente assegnati alla priorità, mentre i thread creati all'esterno del runtime mantengono la Normal priorità precedente quando entrano nel runtime. È possibile ottenere e impostare la priorità di un thread accedendo alla relativa Priority proprietà.
L'esecuzione dei thread viene pianificata in base alla relativa priorità. L'algoritmo di pianificazione usato per determinare l'ordine di esecuzione del thread varia con ogni sistema operativo. Il sistema operativo può anche regolare la priorità del thread in modo dinamico perché lo stato attivo dell'interfaccia utente viene spostato tra il primo piano e lo sfondo.
La priorità di un thread non influisce sullo stato del thread; lo stato del thread deve essere Running prima che il sistema operativo possa pianificarlo.