Accélérer la boucle en utilisant le multithreading en C# (Question)

Parallel extensions est cool, mais cela peut aussi être fait en utilisant simplement le pool de threads comme ceci:

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

namespace noocyte.Threading
{
    class CalcState
    {
        public CalcState(ManualResetEvent reset, string input) {
            Reset = reset;
            Input = input;
        }
        public ManualResetEvent Reset { get; private set; }
        public string Input { get; set; }
    }

    class CalculateMT
    {
        List<string> result = new List<string>();
        List<ManualResetEvent> events = new List<ManualResetEvent>();

        private void Calc() {
            List<string> aList = new List<string>();
            aList.Add("test");

            foreach (var item in aList)
            {
                CalcState cs = new CalcState(new ManualResetEvent(false), item);
                events.Add(cs.Reset);
                ThreadPool.QueueUserWorkItem(new WaitCallback(Calculate), cs);
            }
            WaitHandle.WaitAll(events.ToArray());
        }

        private void Calculate(object s)
        {
            CalcState cs = s as CalcState;
            cs.Reset.Set();
            result.Add(cs.Input);
        }
    }
}

OriginalL'auteur noocyte

Vous devez diviser le travail que vous voulez faire en parallèle. Voici un exemple de comment vous pouvez diviser le travail en deux:

List<string> work = (some list with lots of strings)

//Split the work in two
List<string> odd = new List<string>();
List<string> even = new List<string>();
for (int i = 0; i < work.Count; i++)
{
    if (i % 2 == 0)
    {
        even.Add(work[i]);
    }
    else
    {
        odd.Add(work[i]);
    }
}

//Set up to worker delegates
List<Foo> oddResult = new List<Foo>();
Action oddWork = delegate { foreach (string item in odd) oddResult.Add(CalculateSmth(item)); };

List<Foo> evenResult = new List<Foo>();
Action evenWork = delegate { foreach (string item in even) evenResult.Add(CalculateSmth(item)); };

//Run two delegates asynchronously
IAsyncResult evenHandle = evenWork.BeginInvoke(null, null);
IAsyncResult oddHandle = oddWork.BeginInvoke(null, null);

//Wait for both to finish
evenWork.EndInvoke(evenHandle);
oddWork.EndInvoke(oddHandle);

//Merge the results from the two jobs
List<Foo> allResults = new List<Foo>();
allResults.AddRange(oddResult);
allResults.AddRange(evenResult);

return allResults;

OriginalL'auteur Hallgrim

Pas que j'ai des bons articles ici et maintenant, mais ce que vous voulez faire, c'est quelque chose le long de Producteur-Consommateur avec un pool de threads.

Les Producteurs parcourt et crée des tâches (qui dans ce cas pourrait être à la file d'attente des éléments dans une Liste ou une Pile). Les Consommateurs sont, disons, cinq fils qui lit un article en dehors de la pile, il consomme par le calcul, puis la stocke ailleurs.

De cette façon, le multithreading est limité à seulement ceux de cinq fils, et ils ont tous un travail à faire jusqu'à ce que la pile est vide.

Choses à penser:

• Mettre une protection sur l'entrée et la sortie de la liste, comme un mutex.
• Si l'ordre est important, assurez-vous que l'ordre de sortie est maintenue. Un exemple pourrait être de les stocker dans un SortedList ou quelque chose comme ça.
• Assurez-vous que le CalculateSmth est thread-safe, qu'il n'utilise pas du tout de l'état global.

OriginalL'auteur Mats Fredriksson