Limit Anzahl der Threads C#

Question

Ich habe eine Schleife mit vielen Interaktionen laufen, so dachte ich, Fäden, aber ich weiß nicht, wie die Anzahl der Thread zu steuern:

for (int i = 0; i < 45856582; i = i + 10000) 
{ 
    string result = request.Get(String.Format(mold, i)); 
    Worker temp = new Worker(i, i + 10000); 
    Thread th = new Thread(new ThreadStart(temp.DoWork)); 
    th.Start(); 
} 

Diese Schleife würde zu viele Threads erstellen , wie kann ich es so machen, dass die Schleife aufhört und nicht mehr Threads erzeugt als eine bestimmte Anzahl und warten, bis einer der erzeugten Threads fertig ist, um fortzufahren?

Dies ist der Arbeiter-Klasse:

public class Worker 
{ 
    int startIndex = 0; 
    int endIndex = 0; 

    public Worker(int startIndex , int endIndex) 
    { 
     this.startIndex = startIndex; 
     this.endIndex = endIndex; 
    } 

    public void DoWork() 
    { 

     for (int i = startIndex; i < endIndex; i++) 
     { 
      // Do Work 
     } 
    } 
} 

Answer 1

Ich würde vorschlagen, dass Sie Ihren gesamten Code ändern, um die Parallel Klasse zu verwenden:

https://msdn.microsoft.com/en-us/library/dd781401(v=vs.110).aspx

// Options to the set maximum number of threads. 
// This is not necessary, .NET will try to use the best amount of cores there is. (as pointed out by Panagiotis Kanavos) 
// Overload of method is available without the options parameter 
var options = new ParallelOptions() 
{ 
    MaxDegreeOfParallelism = 4 // maximum number of threads 
}; 

const int batchSize = 1000; 
int totalSize = 45856582; 
int loops = totalSize/batchSize; 

// if there is a rest in the division (in this case 582) 
// then add an extra loop 
if(totalSize % batchSize != 0) 
    loops++; 

// The body on the loop 
Action<int> loopBody = i => 
{ 
    Worker temp = new Worker(i * batchSize, i * batchSize + batchSize); 
    temp.DoWork(); 
}; 

// The result. Check for loopResult.IsCompleted if everything went correctly 
var loopResult = Parallel.For(0, loops, options, loopBody); 

Oder Sie könnten eine Überladung der Methode verwenden, um das Abbrechen usw. zu unterstützen.

Answer 2

Versuchen Parallel.For: https://msdn.microsoft.com/en-us/library/dd460713(v=vs.110).aspx

ParallelOptions options = new ParallelOptions(); 
options.MaxDegreeOfParallelism = 10; //max threads 

Parallel.For(0, 45856582, options, i => { 
    Worker temp = new Worker(i, i + 10000); 
    temp.DoWork(); 
});