priorità inferiore della stringa Task.Factory.StartNew

Question

un codice come di seguito avvierà una nuova discussione per eseguire il lavoro. C'è un modo per controllare la priorità di quel thread?

Task.Factory.StartNew(() => { 
    // everything here will be executed in a new thread. 
    // I want to set the priority of this thread to BelowNormal 
}); 

Answer 1

Questo è uno dei "non fare" quando si decide se utilizzare pool di thread o no ;-)

Maggiori dettagli qui: http://msdn.microsoft.com/en-us/library/0ka9477y.aspx

Quindi la risposta è: "No, non è possibile specificare una particolare priorità per thread creato in Theads Pool"

Come di filettature generali Scommetto che già si conosce Thread.Priority proprietà

Answer 2

Per l'impostazione della priorità con Task, controllare i programmi di pianificazione delle attività personalizzati descritti dall'esperto Microsoft Stephen Toub in this MSDN blog post. Per ulteriori dettagli, non perdere i link ai precedenti due post che menziona nella prima frase.

Per il tuo problema, sembra che potresti voler dare un'occhiata allo QueuedTaskScheduler.

Answer 3

La priorità del thread per Attività può essere impostata all'interno del metodo effettivo che esegue l'attività. Ma non dimenticare di ripristinare la priorità una volta che hai finito per evitare problemi.

Quindi, prima avviare il Task:

new TaskFactory().StartNew(StartTaskMethod);

quindi impostare la priorità del thread:

void StartTaskMethod() 
{ 
    try 
    { 
     // Change the thread priority to the one required. 
     Thread.CurrentThread.Priority = ThreadPriority.AboveNormal; 

     // Execute the task logic. 
     DoSomething(); 
    } 
    finally 
    { 
     // Restore the thread default priority. 
     Thread.CurrentThread.Priority = ThreadPriority.Normal; 
    } 
} 

Quando si cambia la priorità, tenere a mente questo: Why *not* change the priority of a ThreadPool (or Task) thread?

Answer 4

come altri hanno menzionato, è necessario specificare un programma di pianificazione personalizzato per andare con il vostro compito. Sfortunatamente non esiste un programmatore incorporato adatto.

Si potrebbe optare per ParallelExtensionsExtras a cui è collegato Glenn, ma se si desidera qualcosa di semplice da incollare nel codice, provare quanto segue. Utilizzare questo modo:

Task.Factory.StartNew(() => { 
    // everything here will be executed in a thread whose priority is BelowNormal 
}, null, TaskCreationOptions.None, PriorityScheduler.BelowNormal); 

Il codice:

public class PriorityScheduler : TaskScheduler 
{ 
    public static PriorityScheduler AboveNormal = new PriorityScheduler(ThreadPriority.AboveNormal); 
    public static PriorityScheduler BelowNormal = new PriorityScheduler(ThreadPriority.BelowNormal); 
    public static PriorityScheduler Lowest = new PriorityScheduler(ThreadPriority.Lowest); 

    private BlockingCollection<Task> _tasks = new BlockingCollection<Task>(); 
    private Thread[] _threads; 
    private ThreadPriority _priority; 
    private readonly int _maximumConcurrencyLevel = Math.Max(1, Environment.ProcessorCount); 

    public PriorityScheduler(ThreadPriority priority) 
    { 
     _priority = priority; 
    } 

    public override int MaximumConcurrencyLevel 
    { 
     get { return _maximumConcurrencyLevel; } 
    } 

    protected override IEnumerable<Task> GetScheduledTasks() 
    { 
     return _tasks; 
    } 

    protected override void QueueTask(Task task) 
    { 
     _tasks.Add(task); 

     if (_threads == null) 
     { 
      _threads = new Thread[_maximumConcurrencyLevel]; 
      for (int i = 0; i < _threads.Length; i++) 
      { 
       int local = i; 
       _threads[i] = new Thread(() => 
       { 
        foreach (Task t in _tasks.GetConsumingEnumerable()) 
         base.TryExecuteTask(t); 
       }); 
       _threads[i].Name = string.Format("PriorityScheduler: ", i); 
       _threads[i].Priority = _priority; 
       _threads[i].IsBackground = true; 
       _threads[i].Start(); 
      } 
     } 
    } 

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) 
    { 
     return false; // we might not want to execute task that should schedule as high or low priority inline 
    } 
} 

Note:

• i thread di lavoro sono tutti i thread in background, in modo da compiti importanti non dovrebbero essere programmate utilizzando questo scheduler; solo quelli che possono essere scartati se il processo si arresta
• adattato da an implementation by Bnaya Eshet
• Non capisco completamente ogni intervento; solo andando con le scelte di Bnaya per MaximumConcurrencyLevel, GetScheduledTasks e TryExecuteTaskInline.