Thread.Priority Propriété

Définition

Espace de noms:

System.Threading

Assembly:

mscorlib.dll

Obtient ou définit une valeur indiquant la priorité de planification d’un thread.

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

Valeur de propriété

ThreadPriority

Une des ThreadPriority valeurs. La valeur par défaut est Normal.

Exceptions

ThreadStateException

Le thread a atteint un état final, tel que Aborted.

ArgumentException

La valeur spécifiée pour une opération set n’est pas une valeur valide ThreadPriority .

Exemples

L’exemple suivant montre le résultat de la modification de la priorité d’un thread. Trois threads sont créés, la priorité d’un thread est définie ThreadPriority.BelowNormalsur , et la priorité d’une seconde est définie sur ThreadPriority.AboveNormal. Chaque thread incrémente une variable dans une while boucle et s’exécute pour une heure définie.

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

Remarques

Un thread peut être affecté à l’une des valeurs de priorité ThreadPriority suivantes :

• Highest

• AboveNormal

• Normal

• BelowNormal

• Lowest

Les systèmes d’exploitation ne sont pas tenus d’honorer la priorité d’un thread.

Voir aussi

• ThreadPriority
• Planification des threads