क्या यह कंपाइलर ऑप्टिमाइज़ेशन का परिणाम है?

इस कोड स्निपेट में, एक गोरोइन लॉन्च किया जाता है और बार-बार वेरिएबल i बढ़ाता है:

package main

import "time"

func main() {
    i := 1
    go func() {
        for {
            i  
        }
    }()
    
हालाँकि, आउटपुट हमेशा 1 होता है। इस व्यवहार को गो मेमोरी मॉडल और इस कोड के विशिष्ट कार्यान्वयन के लिए जिम्मेदार ठहराया जा सकता है।
गो मेमोरी मॉडल
 गो मेमोरी मॉडल उन स्थितियों को परिभाषित करता है जिसके तहत एक गोरोइन में एक वेरिएबल के रीड्स को एक अलग गोरोइन में एक ही वेरिएबल में लिखने से उत्पन्न मूल्यों का निरीक्षण करने की गारंटी दी जा सकती है। यह साझा किए गए डेटा तक समवर्ती पहुंच के लिए सिंक्रनाइज़ेशन के महत्व पर जोर देता है। किसी भी सिंक्रोनाइज़ेशन ईवेंट के बाद नहीं किया जाता है, जो दर्शाता है कि परिवर्तन तुरंत अन्य गोरआउट्स के लिए दृश्यमान नहीं हो सकते हैं। 
 कंपाइलर इस लूप ऑप्टिमाइज़ेशन को नो-ऑप में सरल बनाकर अनुकूलित कर सकता है। ]कंपाइलर द्वारा अनुकूलन
एक आक्रामक कंपाइलर i स्टेटमेंट को हटा सकता है, प्रभावी रूप से गोरोइन को कम कर सकता है:
के लिए {}
सिंक्रनाइज़ेशन के साथ उदाहरण
 
यह प्रदर्शित करने के लिए कि समस्या सिंक्रनाइज़ेशन की कमी के कारण उत्पन्न हुई है, निम्नलिखित कोड पर विचार करें:
पैकेज मुख्य

आयात (
    "साथ-साथ करना"
    "समय"
)

func मुख्य() {
    एमएक्स := नया(सिंक.म्यूटेक्स)
    मैं := 1
    जाओ func() {
        के लिए {
            एमएक्स.लॉक()
            मैं  
            एमएक्स.अनलॉक()
        }
    }()
    
इस मामले में, आउटपुट अब 1 नहीं, बल्कि एक बड़ी संख्या है, जैसा कि अपेक्षित था। Sync.Mutex सिंक्रोनाइज़ेशन प्रदान करता है और यह सुनिश्चित करता है कि दोनों गोरोइन्स नियंत्रित तरीके से i तक पहुंचें, जिससे गोरोइन्स i को बढ़ा सकें और परिवर्तनों को मुख्य रूटीन में दृश्यमान बना सकें।