Thread.Priority Property (System.Threading)

Switch View :
Classic
Lightweight
ScriptFree
.NET Framework Class Library
Thread.Priority Property

Gets or sets a value indicating the scheduling priority of a thread.

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

Syntax
Visual Basic (Declaration)
Public Property Priority As ThreadPriority
Visual Basic (Usage)
Dim instance As Thread
Dim value As ThreadPriority

value = instance.Priority

instance.Priority = value
C#
public ThreadPriority Priority { get; set; }
C++
public:
property ThreadPriority Priority {
	ThreadPriority get ();
	void set (ThreadPriority value);
}
J#
/** @property */
public ThreadPriority get_Priority ()

/** @property */
public void set_Priority (ThreadPriority value)
JScript
public function get Priority () : ThreadPriority

public function set Priority (value : ThreadPriority)

Property Value

One of the ThreadPriority values. The default value is Normal.
Exceptions
Exception type Condition

ThreadStateException

The thread has reached a final state, such as Aborted.

ArgumentException

The value specified for a set operation is not a valid ThreadPriority value.

Remarks

A thread can be assigned any one of the following priority values:

  • Highest

  • AboveNormal

  • Normal

  • BelowNormal

  • Lowest

Operating systems are not required to honor the priority of a thread.

Example

The following code example shows the result of changing the priority of a thread. Two threads are created and the priority of one thread is set to BelowNormal. Both threads increment a variable in a while loop and run for a set time.

Visual Basic
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
C#
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")); 
    }
}
C++
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;
}
J#
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
Platforms

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

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

Version Information

.NET Framework

Supported in: 2.0, 1.1, 1.0

.NET Compact Framework

Supported in: 2.0, 1.0
See Also