Thread.Priority 属性

定义

命名空间:

System.Threading

程序集:

mscorlib.dll

获取或设置一个值，该值指示线程的计划优先级。

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

属性值

ThreadPriority

其中一个 ThreadPriority 值。 默认值为 Normal。

例外

ThreadStateException

线程已达到最终状态，例如 Aborted。

ArgumentException

为集操作指定的值不是有效 ThreadPriority 值。

示例

以下示例显示了更改线程优先级的结果。 创建三个线程，一个线程的优先级设置为 ThreadPriority.BelowNormal，第二个线程的优先级设置为 ThreadPriority.AboveNormal。 每个线程在循环中递增一个 while 变量，并在一定时间内运行。

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

注解

可以为线程分配以下任一优先级 ThreadPriority 值：

• Highest

• AboveNormal

• Normal

• BelowNormal

• Lowest

操作系统不需要遵循线程的优先级。

另请参阅

• ThreadPriority
• 计划线程