समानांतर के साथ अलग-अलग सारांश परिणाम। फोरएच

Question

मेरे पास foreach लूप है कि मैं समानांतर हूं और मैंने कुछ अजीब देखा है। कोड की तरह

double sum = 0.0; 

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

// Use sum variable below 

लग रहा है जब मैं एक नियमित रूप से foreach पाश मैं अलग परिणाम प्राप्त का उपयोग करें। ComplicatedFunction के अंदर कुछ गहरा हो सकता है लेकिन यह संभव है कि sum चर समानांतरता से अप्रत्याशित रूप से प्रभावित हो रहा है?

Answer 1

यह संभव है कि समांतर चर समानांतरता से अप्रत्याशित रूप से प्रभावित हो रहा है?

हां।
double तक पहुंच परमाणु नहीं है और sum += ... ऑपरेशन कभी थ्रेड-सुरक्षित नहीं है, न कि परमाणु वाले प्रकारों के लिए भी। तो आपके पास कई दौड़ की स्थिति है और परिणाम अप्रत्याशित है।

आप की तरह कुछ इस्तेमाल कर सकते हैं:

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

या, एक छोटा अंकन

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

Answer 2

में आपको लगता है कि sum += ComplicatedFunction के रूप में वास्तव में संचालन का एक समूह से बना जा रहा है के बारे में सोचते हैं, तो कहते हैं:

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

तो अब हम यादृच्छिक रूप से दो (या अधिक) समानांतर उदाहरणों को अंतःस्थापित करते हैं। एक धागा राशि का एक पुराना "पुराना मान" हो सकता है जो इसका गणना करने के लिए उपयोग करता है, जिसके परिणामस्वरूप यह योग के कुछ संशोधित संस्करण के शीर्ष पर वापस लिखता है। यह एक क्लासिक रेस हालत है, क्योंकि अंतःक्रियात्मक तरीके से कैसे किया जाता है, इस पर आधारित कुछ नतीजे नोडेटर्मेनिस्टिक तरीके से खो रहे हैं।

Answer 3

अन्य उत्तरों की तरह उल्लेख किया गया है, sum एकाधिक धागे से चर (जो समानांतर है। फोरएच करता है) को थ्रेड-सुरक्षित ऑपरेशन नहीं है। अद्यतन करने से पहले लॉक प्राप्त करने का मामूली फिक्स को समस्या ठीक करेगा।

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

हालांकि, यह अभी तक एक और समस्या पेश करता है। चूंकि लॉक प्रत्येक पुनरावृत्ति पर अधिग्रहण किया जाता है, इसका मतलब है कि प्रत्येक पुनरावृत्ति का निष्पादन प्रभावी ढंग से क्रमबद्ध किया जाएगा। दूसरे शब्दों में, यह एक सादे पुराने foreach पाश का उपयोग करना बेहतर होगा।

अब, यह अधिकार प्राप्त करने की चाल अलग-अलग और स्वतंत्र चक्स में समस्या को विभाजित करना है। सौभाग्य से यह करना बहुत आसान है जब आप जो करना चाहते हैं वह पुनरावृत्तियों का परिणाम है क्योंकि योग ऑपरेशन कम्यूटेटिव और सहयोगी है और क्योंकि पुनरावृत्तियों के मध्यवर्ती परिणाम स्वतंत्र हैं।

तो यहां यह है कि आप इसे कैसे करते हैं।

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; 
     } 
    });