Korrekte Verwendung von Parallel für Schleife in C#?

Question

In diesem Beispiel ist dies die korrekte Verwendung der Parallel.For Schleife, wenn ich die Anzahl der Threads, die die Funktion DoWork auf zehn gleichzeitig ausführen können, begrenzen möchte? Werden andere Threads blockiert, bis einer der zehn Threads verfügbar wird? Wenn nicht, was ist eine bessere multi-threaded Lösung, die mich diese Funktion noch 6000+ mal ausführen lassen würde?

class Program 
{ 
    static void Main(string[] args) 
    { 
     ThreadExample ex = new ThreadExample(); 
    } 
} 

public class ThreadExample 
{ 
    int limit = 6411; 

    public ThreadExample() 
    { 
     Console.WriteLine("Starting threads..."); 
     int temp = 0; 
     Parallel.For(temp, limit, new ParallelOptions { MaxDegreeOfParallelism = 10 }, i => 
     { 
      DoWork(temp); 
      temp++; 
     }); 
    } 

    public void DoWork(int info) 
    { 
     //Thread.Sleep(50); //doing some work here. 

     int num = info * 5; 

     Console.WriteLine("Thread: {0}  Result: {1}", info.ToString(), num.ToString()); 
    } 
} 

Answer 1

Sie müssen die i auf die Lambda-Funktion als Index übergeben können. Parallel.For entlastet Sie von der Arbeit mit dem Schleifenzähler, aber Sie müssen es verwenden!

Parallel.For(0, limit, new ParallelOptions { MaxDegreeOfParallelism = 10 }, i => 
    { 
     DoWork(i); 
    }); 

Was Ihre anderen Fragen:

• Ja, das wird richtig die Menge an Fäden begrenzen gleichzeitig arbeiten.
• Es sind keine Threads blockiert. Die Iterationen werden in die Warteschlange gestellt, und sobald ein Thread verfügbar ist, nimmt er die nächste Iteration (in einer synchronisierten Weise) von der zu verarbeitenden Warteschlange.