ThreadPriority-Enumeration

Artikel
08/20/2007

Gibt die Planungspriorität eines Thread an.

Namespace: System.Threading
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Enumeration ThreadPriority
'Usage
Dim instance As ThreadPriority

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public enum ThreadPriority

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public enum class ThreadPriority

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum ThreadPriority

SerializableAttribute 
ComVisibleAttribute(true) 
public enum ThreadPriority

Member

	Membername	Beschreibung
	AboveNormal	Der Thread kann anschließend an die Threads mit Highest-Priorität und vor den Threads mit Normal-Priorität geplant werden.
	BelowNormal	Der Thread kann anschließend an die Threads mit Normal-Priorität und vor den Threads mit Lowest-Priorität geplant werden.
	Highest	Der Thread kann vor Threads mit jeder anderen Priorität geplant werden.
	Lowest	Der Thread kann nach Threads mit jeder anderen Priorität geplant werden.
	Normal	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.

Hinweise

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

Jedem Thread ist eine Priorität zugewiesen. Threads, die innerhalb der Common Language Runtime erstellt werden, wird anfänglich die Normal-Priorität zugewiesen, während außerhalb der Common Language Runtime erstellte Threads beim Eintritt in die Runtime ihre vorherige Priorität beibehalten. Sie können die Priorität eines Threads durch den Zugriff auf dessen Priority-Eigenschaft abrufen oder festlegen.

Threads werden auf der Grundlage ihrer Priorität für die Ausführung geplant. Der Planungsalgorithmus, mit dem die Reihenfolge der Threadausführung bestimmt wird, ist bei jedem Betriebssystem unterschiedlich. Das Betriebssystem kann außerdem die Threadpriorität dynamisch anpassen, während der Fokus der Benutzeroberfläche zwischen Vordergrund und Hintergrund verschoben wird.

Die Priorität eines Threads wirkt sich nicht auf den Threadzustand aus, der Running sein muss, bevor er vom Betriebssystem geplant werden kann.

Beispiel

Das folgende Codebeispiel veranschaulicht das Ergebnis einer Änderung der Priorität eines Threads. Es werden zwei Threads erstellt, und die Priorität eines Threads wird auf BelowNormal festgelegt. Beide Threads verwenden zum Inkrementieren einer Variablen eine while-Schleife und werden für eine festgelegte Zeit ausgeführt.

Option Explicit
Option Strict

Imports System
Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        Dim priorityTest As New PriorityTest()

        Dim threadOne As Thread = _
            New Thread(AddressOf priorityTest.ThreadMethod)
        threadOne.Name = "ThreadOne"
        Dim threadTwo As Thread = _
            New Thread(AddressOf priorityTest.ThreadMethod)
        threadTwo.Name = "ThreadTwo"

        threadTwo.Priority = ThreadPriority.BelowNormal
        threadOne.Start()
        threadTwo.Start()

        ' Allow counting for 10 seconds.
        Thread.Sleep(10000)
        priorityTest.LoopSwitch = False
    End Sub

End Class

Public Class PriorityTest

    Dim loopSwitchValue As Boolean 

    Sub New()
        loopSwitchValue = True
    End Sub

    WriteOnly Property LoopSwitch As Boolean
        Set
            loopSwitchValue = Value
        End Set
    End Property

    Sub ThreadMethod()
        Dim threadCount As Long = 0

        While loopSwitchValue
            threadCount += 1
        End While
        
        Console.WriteLine("{0} with {1,11} priority " & _
            "has a count = {2,13}", Thread.CurrentThread.Name, _
            Thread.CurrentThread.Priority.ToString(), _
            threadCount.ToString("N0")) 
    End Sub

End Class

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        PriorityTest priorityTest = new PriorityTest();
        ThreadStart startDelegate = 
            new ThreadStart(priorityTest.ThreadMethod);

        Thread threadOne = new Thread(startDelegate);
        threadOne.Name = "ThreadOne";
        Thread threadTwo = new Thread(startDelegate);
        threadTwo.Name = "ThreadTwo";

        threadTwo.Priority = ThreadPriority.BelowNormal;
        threadOne.Start();
        threadTwo.Start();

        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.LoopSwitch = false;
    }
}

class PriorityTest
{
    bool loopSwitch;

    public PriorityTest()
    {
        loopSwitch = true;
    }

    public bool LoopSwitch
    {
        set{ loopSwitch = value; }
    }

    public void ThreadMethod()
    {
        long threadCount = 0;

        while(loopSwitch)
        {
            threadCount++;
        }
        Console.WriteLine("{0} with {1,11} priority " +
            "has a count = {2,13}", Thread.CurrentThread.Name, 
            Thread.CurrentThread.Priority.ToString(), 
            threadCount.ToString("N0")); 
    }
}

using namespace System;
using namespace System::Threading;
ref class PriorityTest
{
private:
   bool loopSwitch;

public:
   PriorityTest()
   {
      loopSwitch = true;
   }


   property bool LoopSwitch 
   {
      void set( bool value )
      {
         loopSwitch = value;
      }

   }
   void ThreadMethod()
   {
      __int64 threadCount = 0;
      while ( loopSwitch )
      {
         threadCount++;
      }

      Console::WriteLine( "{0} with {1,11} priority "
      "has a count = {2,13}", Thread::CurrentThread->Name, Thread::CurrentThread->Priority.ToString(), threadCount.ToString(  "N0" ) );
   }

};

int main()
{
   PriorityTest^ priorityTest = gcnew PriorityTest;
   ThreadStart^ startDelegate = gcnew ThreadStart( priorityTest, &PriorityTest::ThreadMethod );
   Thread^ threadOne = gcnew Thread( startDelegate );
   threadOne->Name =  "ThreadOne";
   Thread^ threadTwo = gcnew Thread( startDelegate );
   threadTwo->Name =  "ThreadTwo";
   threadTwo->Priority = ThreadPriority::BelowNormal;
   threadOne->Start();
   threadTwo->Start();
   
   // Allow counting for 10 seconds.
   Thread::Sleep( 10000 );
   priorityTest->LoopSwitch = false;
}

import System.*;
import System.Threading.*;
import System.Threading.Thread;

class Test
{
    public static void main(String[] args)
    {
        PriorityTest priorityTest = new PriorityTest();
        ThreadStart startDelegate = new ThreadStart(priorityTest.ThreadMethod);
        Thread threadOne = new Thread(startDelegate);

        threadOne.set_Name("ThreadOne");

        Thread threadTwo = new Thread(startDelegate);

        threadTwo.set_Name("ThreadTwo");
        threadTwo.set_Priority(ThreadPriority.BelowNormal);
        threadOne.Start();
        threadTwo.Start();

        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.set_LoopSwitch(false);
    } //main
} //Test

class PriorityTest
{
    private boolean loopSwitch;

    public PriorityTest()
    {
        loopSwitch = true;
    } //PriorityTest

    /** @property 
     */
    public void set_LoopSwitch(boolean value)
    {
        loopSwitch = value;
    } //set_LoopSwitch

    public void ThreadMethod()
    {
        long threadCount = 0;

        while (loopSwitch) {
            threadCount++;
        }

        Console.WriteLine("{0} with {1,11} priority " + "has a count = {2,13}",
            Thread.get_CurrentThread().get_Name(),
            Thread.get_CurrentThread().get_Priority().toString(),
            ((System.Int32)threadCount).ToString("N0"));
    } //ThreadMethod
} //PriorityTest

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Freigeben über

ThreadPriority-Enumeration

Syntax

Member

Hinweise

Beispiel

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Weitere Ressourcen

Zusätzliche Ressourcen