priorité inférieure de Task.Factory.StartNew thread

Question

un code comme ci-dessous va démarrer un nouveau thread pour faire le travail. Est-il possible de contrôler la priorité de ce 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

C'est l'un des « ne pas faire » lorsque vous décidez d'utiliser ou non pool de threads ou non ;-)

Plus de détails ici: http://msdn.microsoft.com/en-us/library/0ka9477y.aspx

Donc, la réponse est « Non, ne peut pas spécifier une priorité particulière pour le fil créé dans Theads Pool »

au général taraudages Je parie que vous connaissez déjà Thread.Priority propriété

Answer 2

Pour définir la priorité avec Task, consultez les planificateurs de tâches personnalisés décrits par Microsoft expert Stephen Toub dans this MSDN blog post. Pour plus de détails, ne manquez pas les liens vers les deux précédents messages qu'il mentionne dans la première phrase.

Pour votre problème, il semble que vous souhaitiez regarder le QueuedTaskScheduler.

Answer 3

La priorité de thread pour les tâches peut être définie dans la méthode réelle qui exécute la tâche. Mais n'oubliez pas de restaurer la priorité une fois que vous avez terminé pour éviter les problèmes.

Alors d'abord démarrer la tâche:

new TaskFactory().StartNew(StartTaskMethod);

Réglez ensuite la priorité de fil:

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; 
    } 
} 

Lors du changement de priorité, garder à l'esprit ceci: Why *not* change the priority of a ThreadPool (or Task) thread?

Answer 4

Comme d'autres ont mentionné, vous devez spécifier un planificateur personnalisé pour aller avec votre tâche. Malheureusement, il n'y a pas de planificateur intégré approprié.

Vous pouvez opter pour ParallelExtensionsExtras auquel Glenn est lié, mais si vous voulez que quelque chose de simple puisse être simplement collé directement dans votre code, essayez ce qui suit. Utilisez comme ceci:

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

Le code:

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 
    } 
} 

Notes:

• les threads de travail sont toutes les discussions de fond, ne doivent pas être des tâches planifiées si importantes en utilisant ce planificateur; seulement ceux qui peuvent être mis au rebut si le processus s'arrête
• adapté de an implementation by Bnaya Eshet
• Je ne comprends pas complètement chaque dérogation; juste aller avec les choix de Bnaya pour MaximumConcurrencyLevel, GetScheduledTasks et TryExecuteTaskInline.