x86 पर गो परमाणु में वृद्धि ऑपरेटर हैं?

Question

यहां कुछ पृष्ठभूमि है:
मुझे एक रूकी-बाल्टी जैसी चीज़ों के लिए उपयोग की जाने वाली काउंटर वैरिएबल की आवश्यकता होती है। मुझे पता है कि प्रभावी गो, समवर्ती खंड में लीकी-बाल्टी का एक उदाहरण है, लेकिन जिस नंबर को मुझे ट्रैक करने की आवश्यकता है वह बहुत बड़ा हो सकता है, और मुझे लगता है कि इसे ट्रैक करने के लिए चैनल में तत्वों की संख्या का उपयोग करने में अक्षम है। तो मैं संख्या को ट्रैक करने के लिए अलग-अलग दिनचर्या के बीच एक साझा चर का उपयोग करने पर विचार कर रहा हूं।

मैं समझता हूं कि स्पष्ट कॉन्फ़िगरेशन के बिना, सभी जाने के दिनचर्या एक थ्रेड पर मैप की जाती है। लेकिन अगर मैं बहु-कोर कंप्यूटर पर प्रोग्राम में एक से अधिक धागे आवंटित करता हूं, तो वृद्धि ऑपरेटर परमाणु है? क्या यह अलग-अलग मशीनों (int32, float32, आदि) के लिए अलग-अलग मशीनों (x86_32, x86_64, arm) पर समान है?

अधिक ठोस होने के लिए, यदि मेरे पास counter += 1000 एक दिनचर्या में है, और counter -= 512 किसी अन्य दिनचर्या में, और दो दिनचर्या दो धागे में चलती हैं? क्या मुझे धागे-सुरक्षा के बारे में चिंता करने की ज़रूरत है? क्या मैं counter पर ताले लगाऊंगा?

Answer 1

नहीं, वृद्धि को कभी परमाणु माना जाना चाहिए। परमाणु जोड़ कार्यों या एक म्यूटेक्स का प्रयोग करें। जबकि एक अन्य एक म्युटेक्स बिना atomic.AddInt32(counter, -512) किया

import "sync/atomic" 
var counter = new(int32) 

एक goroutine atomic.AddInt32(counter, 1000) कर सकता है:

मान देता है।

आप बल्कि एक म्युटेक्स का प्रयोग करेंगे, तो:

import "sync" 
var counter int32 
var mutex sync.Mutex 

func Add(x int32) { 
    mutex.Lock() 
    defer mutex.Unlock() 
    counter += x 
}