सी ++ 11: आलसी प्रारंभिक के लिए सुरक्षित डबल चेक लॉकिंग। मुमकिन?

Question

मैंने थ्रेड-सुरक्षित डबल चेक लॉकिंग (सिंगलेट्स या आलसी init के लिए) पर विचार करने के कई प्रश्न पढ़े हैं। कुछ धागे में, जवाब यह है कि पैटर्न पूरी तरह टूटा हुआ है, अन्य समाधान का सुझाव देते हैं।

तो मेरा सवाल है: क्या सी ++ में पूरी तरह से थ्रेड-सुरक्षित डबल चेक किए गए लॉकिंग पैटर्न को लिखने का कोई तरीका है? यदि हां, तो यह कैसा दिखता है।

हम सी ++ 11 मान सकते हैं, अगर इससे चीज़ें आसान हो जाती हैं। जहां तक ​​मुझे पता है, सी ++ 11 मेमोरी मॉडल में सुधार हुआ है जो आवश्यक सुधारों को उत्पन्न कर सकता है।

मुझे पता है कि डबल-चेक संरक्षित परिवर्तनीय अस्थिर बनाकर जावा में यह संभव है। चूंकि सी ++ 11 ने जावा के एक से मेमोरी मॉडल के बड़े हिस्से उधार लिया, इसलिए मुझे लगता है कि यह संभव हो सकता है, लेकिन कैसे?

Answer 1

, बस इतना की तरह, lazily initialized Singletons के लिए एक स्थिर स्थानीय चर का उपयोग:

MySingleton* GetInstance() { 
    static MySingleton instance; 
    return &instance; 
} 

(सी ++ 11) मानक पहले से ही गारंटी देता है कि स्थैतिक चर एक threadsafe ढंग से प्रारंभ कर रहे हैं और यह है कि संभावना लगती है इसे कम से कम मजबूत और निष्पादक के रूप में कार्यान्वित करें जो आप स्वयं लिखते हैं।

प्रारंभ की threadsafety (सी ++ 11) मानक के §6.7.4 में पाया जा सकता:

नियंत्रण जबकि चर प्रारंभ किया जा रहा है, समवर्ती निष्पादन करेगा समवर्ती घोषणा में प्रवेश करती है तो प्रारंभिक समापन के लिए प्रतीक्षा करें।

Answer 2

चूंकि आप एक वैध डीसीएलपी सी ++ 11 कार्यान्वयन देखना चाहते थे, तो यहां एक है।

व्यवहार पूरी तरह से थ्रेड-सुरक्षित है और ग्रिज़ली के जवाब में GetInstance() के समान है।

std::mutex mtx; 
std::atomic<MySingleton *> instance_p{nullptr}; 

MySingleton* GetInstance() 
{ 
    auto *p = instance_p.load(std::memory_order_acquire); 

    if (!p) 
    { 
     std::lock_guard<std::mutex> lck{mtx}; 

     p = instance_p.load(std::memory_order_relaxed); 
     if (!p) 
     { 
      p = new MySingleton; 
      instance_p.store(p, std::memory_order_release); 
     } 
    } 

    return p; 
}