Thread.Priority-Eigenschaft

Ruft einen Wert ab, der die Planungspriorität eines Threads angibt, oder legt diesen fest.

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

Syntax

'Declaration
Public Property Priority As ThreadPriority
'Usage
Dim instance As Thread
Dim value As ThreadPriority

value = instance.Priority

instance.Priority = value

public ThreadPriority Priority { get; set; }

public:
property ThreadPriority Priority {
    ThreadPriority get ();
    void set (ThreadPriority value);
}

/** @property */
public ThreadPriority get_Priority ()

/** @property */
public void set_Priority (ThreadPriority value)

public function get Priority () : ThreadPriority

public function set Priority (value : ThreadPriority)

Eigenschaftenwert

Einer der ThreadPriority-Werte. Der Standardwert ist Normal.

Ausnahmen

Hinweise

Einem Thread kann einer der folgenden Prioritätswerte zugewiesen werden:

• Highest

• AboveNormal

• Normal

• BelowNormal

• Lowest

Betriebssysteme müssen die Priorität eines Threads nicht berücksichtigen.

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.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Thread-Klasse
Thread-Member
System.Threading-Namespace
ThreadPriority

Weitere Ressourcen

Scheduling von Threads