ThreadPriority 列舉

定義

指定 Thread 的排程優先權。Specifies the scheduling priority of a Thread.

public enum class ThreadPriority
public enum ThreadPriority
[System.Serializable]
public enum ThreadPriority
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum ThreadPriority
type ThreadPriority = 
Public Enum ThreadPriority
繼承
ThreadPriority
屬性

欄位

AboveNormal 3

Thread 可排定於具有 Highest 優先權的執行緒之後、具有 Normal 優先權的執行緒之前。The Thread can be scheduled after threads with Highest priority and before those with Normal priority.

BelowNormal 1

Thread 可排定於具有 Normal 優先權的執行緒之後、具有 Lowest 優先權的執行緒之前。The Thread can be scheduled after threads with Normal priority and before those with Lowest priority.

Highest 4

Thread 可排定在具有任何他優先權的執行緒之前。The Thread can be scheduled before threads with any other priority.

Lowest 0

Thread 可排定在具有任何其他優先權的執行緒之後。The Thread can be scheduled after threads with any other priority.

Normal 2

Thread 可排定於具有 AboveNormal 優先權的執行緒之後、具有 BelowNormal 優先權的執行緒之前。The Thread can be scheduled after threads with AboveNormal priority and before those with BelowNormal priority. 執行緒依預設具有 Normal 優先權。Threads have Normal priority by default.

範例

下列程式碼範例顯示變更執行緒優先順序的結果。The following code example shows the result of changing the priority of a thread. 系統會建立三個執行緒,其中一個執行緒的優先順序設定為 BelowNormal,而第二個執行緒的優先順序設定為 AboveNormal。Three threads are created, the priority of one thread is set to BelowNormal, and the priority of a second is set to AboveNormal. 每個執行緒會遞增 while 迴圈中的變數,並針對設定的時間執行。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 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
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 定義執行緒優先順序的所有可能值集合。ThreadPriority defines the set of all possible values for a thread priority. 執行緒優先順序會指定一個執行緒與另一個執行緒的相對優先順序。Thread priorities specify the relative priority of one thread versus another.

每個執行緒都有指派的優先權。Every thread has an assigned priority. 在執行時間中建立的執行緒,一開始會被指派 Normal 優先順序,而在執行時間外建立的執行緒則會在進入執行時間時保留其先前的優先權。Threads created within the runtime are initially assigned the Normal priority, while threads created outside the runtime retain their previous priority when they enter the runtime. 您可以藉由存取其 Priority 屬性來取得和設定執行緒的優先順序。You can get and set the priority of a thread by accessing its Priority property.

執行緒會根據它們的優先權排定執行。Threads are scheduled for execution based on their priority. 用來決定執行緒執行順序的排程演算法會因每個作業系統而異。The scheduling algorithm used to determine the order of thread execution varies with each operating system. 當使用者介面的焦點在前景和背景之間移動時,作業系統也可以動態調整執行緒優先順序。The operating system can also adjust the thread priority dynamically as the user interface's focus is moved between the foreground and the background.

執行緒的優先順序不會影響執行緒的狀態。必須先 Running 執行緒的狀態,作業系統才能進行排程。The priority of a thread does not affect the thread's state; the state of the thread must be Running before the operating system can schedule it.

適用於

另請參閱