Esporta (0) Stampa
Espandi tutto
3 di 3 hanno valutato il contenuto utile: - Valuta questo argomento

Enumerazione ThreadPriority

Consente di specificare la priorità di pianificazione di un Thread.

Spazio dei nomi: System.Threading
Assembly: mscorlib (in mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public enum ThreadPriority
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public enum ThreadPriority
SerializableAttribute 
ComVisibleAttribute(true) 
public enum ThreadPriority
 Nome membroDescrizione
Supportato da .NET Compact FrameworkAboveNormalThread può essere pianificato dopo i thread la cui priorità è Highest e prima di quelli la cui priorità è Normal
Supportato da .NET Compact FrameworkBelowNormalThread può essere pianificato dopo i thread la cui priorità è Normal e prima di quelli la cui priorità è Lowest
Supportato da .NET Compact FrameworkHighestThread può essere pianificato prima dei thread con una qualsiasi priorità. 
Supportato da .NET Compact FrameworkLowestThread può essere pianificato dopo i thread con una qualsiasi priorità. 
Supportato da .NET Compact FrameworkNormalThread può essere pianificato dopo i thread la cui priorità è AboveNormal e prima di quelli la cui priorità è BelowNormal. I thread presentano la priorità Normal per impostazione predefinita. 

ThreadPriority consente di definire il set di tutti i possibili valori per una priorità di thread. Con le priorità di thread viene specificata la priorità relativa di un thread rispetto a un altro.

A ciascun thread è stata assegnata una priorità. Ai thread creati nel runtime viene inizialmente assegnata la priorità Normal mentre i thread creati al di fuori del runtime conservano la precedente priorità al momento dell'immissione nel runtime. Per ottenere e impostare la priorità di un thread, accedere alle relative priorità Priority.

L'esecuzione dei thread viene pianificata in base alla priorità ad essi assegnata. L'algoritmo di pianificazione utilizzato per determinare l'ordine di esecuzione del thread varia in base al sistema operativo. Il sistema operativo può regolare la priorità del thread anche in modo dinamico in quanto lo stato attivo dell'interfaccia utente si sposta tra il primo piano e il background.

La priorità di un thread non influisce sullo stato di un thread; lo stato di un thread deve essere Running affinché il sistema operativo possa eseguire la pianificazione.

Nell'esempio di codice riportato di seguito viene illustrato il risultato della modifica della priorità di un thread. Vengono creati due thread e la priorità di un thread è impostata su BelowNormal. Entrambi i thread incrementano una variabile in un ciclo while e vengono eseguiti per un periodo di tempo impostato.

using System;
using System.Threading;

class Test
{
    static void Main()
    {
        PriorityTest priorityTest = new PriorityTest();
        ThreadStart startDelegate = 
            new ThreadStart(priorityTest.ThreadMethod);

        Thread threadOne = new Thread(startDelegate);
        threadOne.Name = "ThreadOne";
        Thread threadTwo = new Thread(startDelegate);
        threadTwo.Name = "ThreadTwo";

        threadTwo.Priority = ThreadPriority.BelowNormal;
        threadOne.Start();
        threadTwo.Start();

        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.LoopSwitch = false;
    }
}

class PriorityTest
{
    bool loopSwitch;

    public PriorityTest()
    {
        loopSwitch = true;
    }

    public bool LoopSwitch
    {
        set{ loopSwitch = value; }
    }

    public void ThreadMethod()
    {
        long threadCount = 0;

        while(loopSwitch)
        {
            threadCount++;
        }
        Console.WriteLine("{0} with {1,11} priority " +
            "has a count = {2,13}", Thread.CurrentThread.Name, 
            Thread.CurrentThread.Priority.ToString(), 
            threadCount.ToString("N0")); 
    }
}

import System.*;
import System.Threading.*;
import System.Threading.Thread;

class Test
{
    public static void main(String[] args)
    {
        PriorityTest priorityTest = new PriorityTest();
        ThreadStart startDelegate = new ThreadStart(priorityTest.ThreadMethod);
        Thread threadOne = new Thread(startDelegate);

        threadOne.set_Name("ThreadOne");

        Thread threadTwo = new Thread(startDelegate);

        threadTwo.set_Name("ThreadTwo");
        threadTwo.set_Priority(ThreadPriority.BelowNormal);
        threadOne.Start();
        threadTwo.Start();

        // Allow counting for 10 seconds.
        Thread.Sleep(10000);
        priorityTest.set_LoopSwitch(false);
    } //main
} //Test

class PriorityTest
{
    private boolean loopSwitch;

    public PriorityTest()
    {
        loopSwitch = true;
    } //PriorityTest

    /** @property 
     */
    public void set_LoopSwitch(boolean value)
    {
        loopSwitch = value;
    } //set_LoopSwitch

    public void ThreadMethod()
    {
        long threadCount = 0;

        while (loopSwitch) {
            threadCount++;
        }

        Console.WriteLine("{0} with {1,11} priority " + "has a count = {2,13}",
            Thread.get_CurrentThread().get_Name(),
            Thread.get_CurrentThread().get_Priority().toString(),
            ((System.Int32)threadCount).ToString("N0"));
    } //ThreadMethod
} //PriorityTest

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile per Pocket PC, Windows Mobile per Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0 1.1 1.0

.NET Compact Framework

Supportato in: 2.0 1.0
Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft. Tutti i diritti riservati.