Quand utiliser le pool de threads en C# ?

Question

J'ai essayé d'apprendre la programmation multithread en C# et je ne sais pas quand il est préférable d'utiliser le pool de threads ou de créer mes propres threads. Un livre recommande d'utiliser le pool de threads uniquement pour les petites tâches (quoi que cela veuille dire), mais je n'arrive pas à trouver de véritables directives. Quelles sont les considérations que vous utilisez pour prendre cette décision de programmation ?

Answer 1

La plupart du temps, vous pouvez utiliser le pool car vous évitez le processus coûteux de création du fil.

Toutefois, dans certains cas, vous pouvez souhaiter créer un fil de discussion. Par exemple, si vous n'êtes pas le seul à utiliser le pool de threads et que le thread que vous créez a une longue durée de vie (pour éviter de consommer des ressources partagées) ou si vous voulez contrôler la taille de la pile du thread.

Answer 2

N'oubliez pas d'enquêter sur le travailleur de fond.

Je trouve que pour beaucoup de situations, il me donne juste ce que je veux sans avoir à faire le gros du travail.

A la vôtre.

Answer 3

J'utilise généralement le Threadpool lorsque j'ai besoin de faire quelque chose sur un autre thread et que je ne me soucie pas vraiment du moment où il s'exécute ou se termine. Quelque chose comme la journalisation ou peut-être même le téléchargement d'un fichier en arrière-plan (bien qu'il y ait de meilleures façons de faire cela en asynchrone). J'utilise mon propre thread quand j'ai besoin de plus de contrôle. De plus, j'ai découvert que l'utilisation d'une file d'attente Threadsafe (modifiez la vôtre) pour stocker les "objets de commande" est intéressante lorsque j'ai plusieurs commandes sur lesquelles je dois travailler dans >1 thread. Ainsi, vous pouvez diviser un fichier Xml et mettre chaque élément dans une file d'attente, puis faire travailler plusieurs threads pour effectuer un traitement sur ces éléments. J'ai écrit une telle file d'attente à l'université (VB.net !) que j'ai converti en C#. Je l'ai inclus ci-dessous sans raison particulière (ce code peut contenir quelques erreurs).

using System.Collections.Generic;
using System.Threading;

namespace ThreadSafeQueue {
    public class ThreadSafeQueue<T> {
        private Queue<T> _queue;

        public ThreadSafeQueue() {
            _queue = new Queue<T>();
        }

        public void EnqueueSafe(T item) {
            lock ( this ) {
                _queue.Enqueue(item);
                if ( _queue.Count >= 1 )
                    Monitor.Pulse(this);
            }
        }

        public T DequeueSafe() {
            lock ( this ) {
                while ( _queue.Count <= 0 )
                    Monitor.Wait(this);

                return this.DeEnqueueUnblock();

            }
        }

        private T DeEnqueueUnblock() {
            return _queue.Dequeue();
        }
    }
}

Answer 4

Je voulais un pool de threads pour répartir le travail entre les cœurs avec un temps de latence aussi faible que possible, et qui n'avait pas besoin d'être compatible avec d'autres applications. J'ai constaté que les performances du pool de threads de .NET n'étaient pas aussi bonnes qu'elles pourraient l'être. Je savais que je voulais un thread par cœur, alors j'ai écrit ma propre classe de substitution de pool de threads. Le code est fourni en réponse à une autre question de StackOverflow. par ici .

Pour répondre à la question initiale, le pool de threads est utile pour décomposer les calculs répétitifs en parties qui peuvent être exécutées en parallèle (en supposant qu'elles puissent être exécutées en parallèle sans changer le résultat). La gestion manuelle des threads est utile pour des tâches telles que l'interface utilisateur et les entrées-sorties.