Thread.Priority Property

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

public System.Threading.ThreadPriority Priority { get; set; }

member this.Priority : System.Threading.ThreadPriority with get, set

Public Property Priority As ThreadPriority

Property Value

One of the ThreadPriority values. The default value is Normal.

Exceptions

Examples

The following example shows the result of changing the priority of a thread. Three threads are created, the priority of one thread is set to ThreadPriority.BelowNormal, and the priority of a second is set to ThreadPriority.AboveNormal. Each thread increments a variable in a while loop and runs for a set time.

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

open System
open System.Threading

type PriorityTest() =
 [<VolatileField>]
 static let mutable loopSwitch: bool = true

 [<ThreadStatic; DefaultValue>]
 static val mutable private threadCount: int

 member _.ThreadMethod() =
 while loopSwitch do
 PriorityTest.threadCount <- PriorityTest.threadCount + 1

 printfn
 $"""{Thread.CurrentThread.Name, -11} with {Thread.CurrentThread.Priority, 11} priority has a count = {PriorityTest.threadCount.ToString "N0", 13}"""

 do loopSwitch <- true

 member _.LoopSwitch
 with set (value) = loopSwitch <- value

let priorityTest = PriorityTest()

let thread1 = Thread priorityTest.ThreadMethod
thread1.Name <- "ThreadOne"
let thread2 = Thread priorityTest.ThreadMethod
thread2.Name <- "ThreadTwo"
thread2.Priority <- ThreadPriority.BelowNormal
let thread3 = 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

// 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

Remarks

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

• Highest

• AboveNormal

• Normal

• BelowNormal

• Lowest

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

See also

• ThreadPriority
• Scheduling threads