ThreadPriority Enumeration

Referenz

Definition

Namespace:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt die Planungspriorität eines Thread an.

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

Vererbung: Object

ValueType

Enum
ThreadPriority

Attribute: SerializableAttribute ComVisibleAttribute

Felder

AboveNormal	3	Der Thread kann anschließend an die Threads mit `Highest`-Priorität und vor den Threads mit `Normal`-Priorität geplant werden.
BelowNormal	1	Der Thread kann anschließend an die Threads mit `Normal`-Priorität und vor den Threads mit `Lowest`-Priorität geplant werden.
Highest	4	Der Thread kann vor Threads mit jeder anderen Priorität geplant werden.
Lowest	0	Der Thread kann nach Threads mit jeder anderen Priorität geplant werden.
Normal	2	Der Thread kann anschließend an die Threads mit `AboveNormal`-Priorität und vor den Threads mit `BelowNormal`-Priorität geplant werden. Threads haben standardmäßig `Normal`-Priorität.

Beispiele

Das folgende Codebeispiel zeigt das Ergebnis einer Änderung der Priorität eines Threads. Es werden drei Threads erstellt, die Priorität eines Threads ist auf BelowNormal festgelegt, und die Priorität eines zweiten Threads ist auf AboveNormal festgelegt. Jeder Thread erhöht eine Variable in einer while Schleife und wird für eine festgelegte Zeit ausgeführt.

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

Hinweise

ThreadPriority definiert den Satz aller möglichen Werte für eine Threadpriorität. Threadprioritäten geben die relative Priorität eines Threads gegenüber einem anderen an.

Jeder Thread hat eine zugewiesene Priorität. Threads, die innerhalb der Runtime erstellt werden, erhalten zunächst die Normal Priorität, während Threads, die außerhalb der Runtime erstellt wurden, ihre vorherige Priorität beibehalten, wenn sie in die Runtime gelangen. Sie können die Priorität eines Threads abrufen und festlegen, indem Sie auf seine Priority Eigenschaft zugreifen.

Die Ausführung von Threads wird basierend auf ihrer Priorität geplant. Der Planungsalgorithmus, der zum Bestimmen der Reihenfolge der Threadausführung verwendet wird, variiert je nach Betriebssystem. Das Betriebssystem kann die Threadpriorität auch dynamisch anpassen, wenn der Fokus der Benutzeroberfläche zwischen Vordergrund und Hintergrund verschoben wird.

Die Priorität eines Threads wirkt sich nicht auf den Zustand des Threads aus. der Zustand des Threads muss sein Running , bevor das Betriebssystem ihn planen kann.

Gilt für: