webentwicklung-frage-antwort-db.com.de

Wie kann ich diesen foreach-Code in Parallel.ForEach konvertieren?

Ich bin ein bisschen verwirrt über Parallel.ForEach.
Was ist Parallel.ForEach Und was genau macht es?
Bitte verweisen Sie nicht auf einen MSDN-Link.

Hier ist ein einfaches Beispiel:

string[] lines = File.ReadAllLines(txtProxyListPath.Text);
List<string> list_lines = new List<string>(lines);

foreach (string line in list_lines)
{
    //My Stuff
}

Wie kann ich dieses Beispiel mit Parallel.ForEach Umschreiben?

171
SilverLight
string[] lines = File.ReadAllLines(txtProxyListPath.Text);
List<string> list_lines = new List<string>(lines);
Parallel.ForEach(list_lines, line =>
{
    //Your stuff
});
113
L.B

Foreach-Schleife:

  • Iterationen finden nacheinander statt
  • jede Schleife wird von einem einzelnen Thread ausgeführt.
  • jede foreach-Schleife ist in jedem Framework von .NET definiert
  • Die Ausführung von langsamen Prozessen kann langsamer sein, da sie seriell ausgeführt werden
    • Prozess 2 kann erst gestartet werden, wenn 1 abgeschlossen ist. Prozess 3 kann nicht starten, bis 2 & 1 fertig sind ...
  • Die Ausführung von schnellen Prozessen kann schneller sein, da kein Threading-Aufwand entsteht

Parallel.ForEach:

  • Die Ausführung erfolgt parallel.
  • Parallel.ForEach verwendet mehrere Threads.
  • Parallel.ForEach ist in Frameworks mit .Net 4.0 und höher definiert.
  • Die Ausführung von langsamen Prozessen kann schneller sein, als sie ausgeführt werden können parallel
    • Die Prozesse 1, 2 und 3 können gleichzeitig ausgeführt werden (siehe wiederverwendete Threads im folgenden Beispiel).
  • Die Ausführung von schnellen Prozessen kann langsamer sein, da zusätzlicher Threading-Aufwand entsteht

Das folgende Beispiel zeigt deutlich den Unterschied zwischen herkömmlichen foreach-Schleifen und

Parallel.ForEach () - Beispiel

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
namespace ParallelForEachExample
{
    class Program
    {
        static void Main()
        {
            string[] colors = {
                                  "1. Red",
                                  "2. Green",
                                  "3. Blue",
                                  "4. Yellow",
                                  "5. White",
                                  "6. Black",
                                  "7. Violet",
                                  "8. Brown",
                                  "9. Orange",
                                  "10. Pink"
                              };
            Console.WriteLine("Traditional foreach loop\n");
            //start the stopwatch for "for" loop
            var sw = Stopwatch.StartNew();
            foreach (string color in colors)
            {
                Console.WriteLine("{0}, Thread Id= {1}", color, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10);
            }
            Console.WriteLine("foreach loop execution time = {0} seconds\n", sw.Elapsed.TotalSeconds);
            Console.WriteLine("Using Parallel.ForEach");
            //start the stopwatch for "Parallel.ForEach"
             sw = Stopwatch.StartNew();
            Parallel.ForEach(colors, color =>
            {
                Console.WriteLine("{0}, Thread Id= {1}", color, Thread.CurrentThread.ManagedThreadId);
                Thread.Sleep(10);
            }
            );
            Console.WriteLine("Parallel.ForEach() execution time = {0} seconds", sw.Elapsed.TotalSeconds);
            Console.Read();
        }
    }
}

Ausgabe

Traditional foreach loop
1. Red, Thread Id= 10
2. Green, Thread Id= 10
3. Blue, Thread Id= 10
4. Yellow, Thread Id= 10
5. White, Thread Id= 10
6. Black, Thread Id= 10
7. Violet, Thread Id= 10
8. Brown, Thread Id= 10
9. Orange, Thread Id= 10
10. Pink, Thread Id= 10
foreach loop execution time = 0.1054376 seconds

Verwenden von Parallel.ForEach-Beispiel

1. Red, Thread Id= 10
3. Blue, Thread Id= 11
4. Yellow, Thread Id= 11
2. Green, Thread Id= 10
5. White, Thread Id= 12
7. Violet, Thread Id= 14
9. Orange, Thread Id= 13
6. Black, Thread Id= 11
8. Brown, Thread Id= 10
10. Pink, Thread Id= 12
Parallel.ForEach() execution time = 0.055976 seconds
258
Jignesh.Raj
string[] lines = File.ReadAllLines(txtProxyListPath.Text);

// No need for the list
// List<string> list_lines = new List<string>(lines); 

Parallel.ForEach(lines, line =>
{
    //My Stuff
});

Dadurch werden die Zeilen innerhalb der Schleife parallel analysiert. Wenn Sie eine detailliertere, weniger "referenzorientierte" Einführung in die Parallel-Klasse wünschen, habe ich eine Serie über die TPL geschrieben, die ein Abschnitt über Parallel.ForEach enthält.

43
Reed Copsey

Verwenden Sie für große Dateien den folgenden Code (Sie haben weniger Speicherbedarf)

Parallel.ForEach(File.ReadLines(txtProxyListPath.Text), line => {
    //Your stuff
});
8
Samuel LEMAITRE

Diese Zeilen haben für mich funktioniert.

string[] lines = File.ReadAllLines(txtProxyListPath.Text);
var options = new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 10 };
Parallel.ForEach(lines , options, (item) =>
{
 //My Stuff
});
0
Prince Prasad