ThreadPriority Enumerazione

Definizione

public enum class ThreadPriority

public enum ThreadPriority

[System.Serializable]
public enum ThreadPriority

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum ThreadPriority

type ThreadPriority = 

[<System.Serializable>]
type ThreadPriority = 

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadPriority = 

Public Enum ThreadPriority

Ereditarietà

Object

ValueType

Enum

ThreadPriority

Attributi

SerializableAttribute ComVisibleAttribute

Campi

Esempio

Nell'esempio di codice seguente viene illustrato il risultato della modifica della priorità di un thread. Vengono creati tre thread, la priorità di un thread è impostata su BelowNormal e la priorità di un secondo è impostata su AboveNormal. Ogni thread incrementa una variabile in un while ciclo e viene eseguita per un periodo di tempo impostato.

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

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

Commenti

ThreadPriority definisce il set di tutti i valori possibili per una priorità di thread. Le priorità dei thread specificano la priorità relativa di un thread rispetto a un'altra.

Ogni thread ha una priorità assegnata. I thread creati all'interno del runtime vengono inizialmente assegnati alla Normal priorità, mentre i thread creati all'esterno del runtime mantengono la priorità precedente quando accedono al runtime. È possibile ottenere e impostare la priorità di un thread accedendo alla relativa Priority proprietà.

L'esecuzione dei thread viene pianificata in base alla relativa priorità. L'algoritmo di pianificazione usato per determinare l'ordine di esecuzione del thread varia in base a ogni sistema operativo. Il sistema operativo può anche regolare dinamicamente la priorità del thread quando lo stato attivo dell'interfaccia utente viene spostato tra il primo piano e lo sfondo.

La priorità di un thread non influisce sullo stato del thread; lo stato del thread deve essere Running prima che il sistema operativo possa pianificarlo.

Vedi anche

• Thread
• Pianificazione dei thread