Unterschiedliche Summierungsergebnisse mit Parallel.ForEach

Question

Ich habe eine foreach Schleife, die ich parallelisiere und mir ist etwas merkwürdig aufgefallen. Der Code sieht aus wie

double sum = 0.0; 

Parallel.ForEach(myCollection, arg => 
{ 
    sum += ComplicatedFunction(arg); 
}); 

// Use sum variable below 

Wenn ich eine regelmäßige foreach Schleife verwende ich unterschiedliche Ergebnisse erhalten. Es kann etwas tiefer in der ComplicatedFunction sein, aber es ist möglich, dass die sum Variable unerwartet von der Parallelisierung betroffen ist?

Answer 1

ist es möglich, dass die Summenvariable unerwartet von der Parallelisierung betroffen ist?

Ja.
Der Zugriff auf eine double ist nicht atomar und die sum += ... Operation ist nie threadsicher, nicht einmal für atomare Typen. Sie haben also mehrere Rennbedingungen und das Ergebnis ist unvorhersehbar.

double sum = myCollection.AsParallel().Sum(arg => ComplicatedFunction(arg)); 

oder

double sum = myCollection.AsParallel().Sum(ComplicatedFunction); 

Answer 2

Wenn Sie darüber nachdenken, dass sum += ComplicatedFunction als eigentlich aus einer Reihe von Operationen, etwa in einer kürzeren Schreibweise:

Sie so etwas wie verwenden könnte

r1 <- Load current value of sum 
r2 <- ComplicatedFunction(...) 
r1 <- r1 + r2 

Also verschachteln wir zufällig zwei (oder mehr) parallele Instanzen davon. Ein Thread kann einen veralteten "alten Wert" der Summe halten, den er benutzt, um seine Berechnung durchzuführen, dessen Ergebnis er über eine modifizierte Version der Summe zurückschreibt. Es ist eine klassische Race-Bedingung, weil einige Ergebnisse nichtdeterministisch verloren gehen, je nachdem, wie das Interleaving durchgeführt wird.

Answer 3

Wie die anderen Antworten erwähnt, ist das Aktualisieren der sum Variable aus mehreren Threads (was Parallel.ForEach tut) keine Thread-sichere Operation. Die triviale Behebung des Erlangens einer Sperre vor der Aktualisierung behebt das Problem.

double sum = 0.0; 
Parallel.ForEach(myCollection, arg => 
{ 
    lock (myCollection) 
    { 
    sum += ComplicatedFunction(arg); 
    } 
}); 

Allerdings führt das ein weiteres Problem ein. Da die Sperre bei jeder Iteration akquiriert wird, bedeutet dies, dass die Ausführung jeder Iteration effektiv serialisiert wird. Mit anderen Worten, es wäre besser gewesen, einfach einen einfachen alten foreach Loop zu verwenden.

Jetzt ist der Trick, dies richtig zu machen, das Problem in separate und unabhängige Chucks zu teilen. Glücklicherweise ist das sehr einfach zu tun, wenn Sie nur das Ergebnis der Iterationen summieren wollen, weil die Summenoperation kommutativ und assoziativ ist und weil die Zwischenergebnisse der Iterationen unabhängig sind.

Also hier ist, wie Sie es tun.

double sum = 0.0; 
Parallel.ForEach(myCollection, 
    () => // Initializer 
    { 
     return 0D; 
    }, 
    (item, state, subtotal) => // Loop body 
    { 
     return subtotal += ComplicatedFunction(item); 
    }, 
    (subtotal) => // Accumulator 
    { 
     lock (myCollection) 
     { 
      sum += subtotal; 
     } 
    });