Comment réutiliser les threads .NET 3.5

J'ai un sous-programme qui traite les gros blocs d'informations. Afin de rendre l'utilisation de l'ensemble de la CPU, il divise le travail dans des threads séparés. Après tous les threads ont terminé, elle se termine. J'ai lu que la création et à la destruction de threads utilise beaucoup de frais généraux, de sorte j'ai essayé d'utiliser le pool de threads, mais qui en fait s'exécute plus lentement que la création de mon propre fils. Comment puis-je créer mon propre fils lorsque le programme s'exécute, puis garder les réutiliser? J'ai vu certaines personnes disent qu'il ne peut pas être fait, mais le pool de threads t-elle donc ça doit être possible, non?

Voici la partie du code qui lance de nouveaux threads /utilise le pool de threads:

//initialization for threads
Thread[] AltThread = null;
if (NumThreads > 1)
AltThread = new Thread[pub.NumThreads - 1];
do
{
if (NumThreads > 1)
{   //split the matrix up into NumThreads number of even-sized blocks and execute on separate threads
int ThreadWidth = DataWidth / NumThreads;
if (UseThreadPool) //use threadpool threads
{
for (int i = 0; i < NumThreads - 1; i++)
{
ThreadPool.QueueUserWorkItem(ComputePartialDataOnThread, 
new object[] { AltEngine[i], ThreadWidth * (i + 1), ThreadWidth * (i + 2) });
}
//get number of threads available after queue
System.Threading.Thread.Sleep(0);
int StartThreads, empty, EndThreads;
ThreadPool.GetAvailableThreads(out StartThreads, out empty);
ComputePartialData(ThisEngine, 0, ThreadWidth);
//wait for all threads to finish
do
{
ThreadPool.GetAvailableThreads(out EndThreads, out empty);
System.Threading.Thread.Sleep(1);
} while (StartThreads - EndThreads > 0);
}
else //create new threads each time (can we reuse these?)
{
for (int i = 0; i < NumThreads - 1; i++)
{
AltThread[i] = new Thread(ComputePartialDataOnThread);
AltThread[i].Start(new object[] { AltEngine[i], ThreadWidth * (i + 1), ThreadWidth * (i + 2) });
}
ComputePartialData(ThisEngine, 0, ThreadWidth);
//wait for all threads to finish
foreach (Thread t in AltThread)
t.Join(1000);
foreach (Thread t in AltThread)
if (t.IsAlive) t.Abort();
}
}
}

ComputePartialDataOnThread simplement unpackages les informations et les appels ComputePartialData. Les données qui seront traitées est partagé entre les threads (ils n'essayez pas de lire/écrire les mêmes endroits). AltEngine[] est un calcul séparé du moteur pour chaque thread.

L'opération s'exécute environ 10 à 20% en utilisant le pool de threads.

  • Pourriez-vous poster votre code afin que nous puissions voir ce que vous faites? Il est possible que vous êtes en train de faire quelque chose de mal avec le pool de threads qui est à l'origine pour être si lent.
  • C'est peut-être lent que dans votre essai, c'est à dire que vous frappez le thread initial comte, donc il a de créer plusieurs threads pour répondre à vos besoins. Essayez de régler manuellement minimum nombre de threads dans la piscine avant de lancer les tests.
  • Le nombre de threads est destiné à correspondre au nombre de cœurs de processeur. Dans ce cas, c'est seulement 2.
  • Veuillez vous débarrasser de votre utilisation de Thread.Abort. Il s'agit de la pire des fonction, vous pouvez l'appeler. Que faire si votre fils était en train de faire quelque chose de critique? D'un coup, vous êtes mort.
  • L'obtention de ce droit est délicate. Cependant, l'utilisation du pool de threads est généralement va être la meilleure façon de parallelising de calcul lié opérations. Je recommande absolument la lecture de Jeffrey Richter livre "CLR via C#" (partie V "Threading") pour une explication détaillée de comment et quand le multi-thread.
  • Vous interrompez le fils dans l'autre cas. Serait-il possible que ComputePartialData(ThisEngine, 0, ThreadWidth) est très rapide, ce qui sera la cause de votre thread principal pour abandonner ses threads de travail prématurément. Qu'advient-il si vous utilisez t.Join() à la place? Comment beaucoup plus lent sera le cas d'autre alors?

InformationsquelleAutor HypnoToad | 2011-04-29
  1. 13

    Cela sonne comme une assez exigence commune qui peut être résolu par un multi-thread producteur-consommateur de la file d'attente. Les fils sont maintenus "vivant" et sont signalées pour faire le travail quand un nouveau travail est ajouté à la file d'attente. Le travail est représenté par un délégué, (dans votre cas ComputePartialDataOnThread) et les données transmises au délégué est ce qui est mis en file d'attente (dans votre cas, les paramètres de ComputePartialDataOnThread). La fonctionnalité utile est que la mise en œuvre de la gestion des threads de travail et le réel algorithmes sont séparés. Ici, c'est le p-c file d'attente:

    public class SuperQueue<T> : IDisposable where T : class
{
readonly object _locker = new object();
readonly List<Thread> _workers;
readonly Queue<T> _taskQueue = new Queue<T>();
readonly Action<T> _dequeueAction;
///<summary>
///Initializes a new instance of the <see cref="SuperQueue{T}"/> class.
///</summary>
///<param name="workerCount">The worker count.</param>
///<param name="dequeueAction">The dequeue action.</param>
public SuperQueue(int workerCount, Action<T> dequeueAction)
{
_dequeueAction = dequeueAction;
_workers = new List<Thread>(workerCount);
//Create and start a separate thread for each worker
for (int i = 0; i < workerCount; i++)
{
Thread t = new Thread(Consume) { IsBackground = true, Name = string.Format("SuperQueue worker {0}",i )};
_workers.Add(t);
t.Start();
}
}
///<summary>
///Enqueues the task.
///</summary>
///<param name="task">The task.</param>
public void EnqueueTask(T task)
{
lock (_locker)
{
_taskQueue.Enqueue(task);
Monitor.PulseAll(_locker);
}
}
///<summary>
///Consumes this instance.
///</summary>
void Consume()
{
while (true)
{
T item;
lock (_locker)
{
while (_taskQueue.Count == 0) Monitor.Wait(_locker);
item = _taskQueue.Dequeue();
}
if (item == null) return;
//run actual method
_dequeueAction(item);
}
}
///<summary>
///Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
///</summary>
public void Dispose()
{
//Enqueue one null task per worker to make each exit.
_workers.ForEach(thread => EnqueueTask(null));
_workers.ForEach(thread => thread.Join());
}
}

    Comme les précédentes affiches ont dit, il y a beaucoup construit dans les structures (regardez TPL ), qui utilisent le pool de threads, ce qui, vous voudrez peut-être vérifier avant de mettre en œuvre votre propre file d'attente.

    • Merci, cela ressemble à un bon moyen de le faire. Je vais voir si cette classe est plus rapide que le pool de threads.
    • Avez-vous utilisé avec succès, et a été plus rapide?
    • Oui, dans sa dernière incarnation, c'est un peu différent et plus complexe que ça, mais la même idée. Le fils d'aller dans un mode de priorité faible après quelques secondes d'inactivité, puis la sortie après 30 secondes d'inactivité. Ceci est en accord avec le type et la fréquence de travail qu'ils attendent. Il tourne à la même vitesse que le pool de threads, mais il est moins nerveux. Aussi, j'ai trouvé que je pouvais obtenir un meilleur CPU de la mise en cache par diviser les données en lignes adjacentes, par opposition à des segments, qui a également fait une différence.
    InformationsquelleAutor dashton
  2. 2

    Donc de la manière habituelle, on pourrait faire c'est d'avoir chaque thread entrypoint essentiellement de faire quelque chose de semblable (c'est juste un algorithme, pas de code C#, désolé):

    1. Vérifier pour voir si vous avez du travail à faire
    2. Effectuer des travaux s'trouvé
    3. Attendre un signal

    De l'autre côté, chaque fois que vous avez plus de travail pour votre thread de l'ajouter à la file d'attente de travail à faire, et puis votre fil dans l'essence est d'être réutilisées. C'est assez similaire à la façon dont on pourrait mettre en œuvre un pool de threads par eux-mêmes (si vous êtes dans le moteur d'exécution, vous pourriez faire quelques autres choses à vous aider, mais ce n'est pas un super big deal").

    • Comment peut-il attendre un signal sans consommatrices de CPU?
    • Lorsque vous attendez un signal que vous venez de mettre à l'état bloqué, et quand quelqu'un signale le planificateur vous fait praticable. Tout bloqué, vous n'obtenez pas de temps CPU (toutefois, cela s'avère ne pas être le plus efficace de la chose, donc généralement le système d'exploitation sera occupé attendre un peu). Les Threads sont bloqués ne consomment pas d'énergie du processeur.
    InformationsquelleAutor Aurojit Panda
  3. 0

    Voici un fil qui en parle très chose: Une coutume thread-piscine/classe de file d'attente.

    • Cette classe ressemble, c'est le lancement de backgroundworkers. Ils ne nécessitent pas les mêmes coûts indirects de lancement des threads?
    InformationsquelleAutor seairth