परमाणु संचालन सी ++

Question

में मैं सी ++ कार्यों का एक सेट है। क्या इसे प्राप्त करने का कोई तरीका है?

Answer 1

सामान्य रूप से, नहीं। परमाणु संचालन बहुत सटीक परिभाषित हैं। आप जो चाहते हैं वह एक सैमफोर या म्यूटेक्स है।

Answer 2

एक तरीका यह है कि आप इसे पूरा कर सकते हैं नई (सी ++ 11) विशेषताएं std::mutex और std::lock_guard का उपयोग करना है।

प्रत्येक संरक्षित संसाधन के लिए, आप एक वैश्विक std::mutex को तुरंत चालू करते हैं; प्रत्येक थ्रेड तो, कि म्युटेक्स ताले के रूप में यह आवश्यकता है, एक std::lock_guard के निर्माण से:

#include <thread> 
#include <iostream> 
#include <mutex> 
#include <vector> 

// A single mutex, shared by all threads. It is initialized 
// into the "unlocked" state 
std::mutex m; 

void funcB() { 
    std::cout << "Hello "; 
} 
void funcC() { 
    std::cout << "World." << std::endl; 
} 
void funcA(int i) { 

    // The creation of lock_guard locks the mutex 
    // for the lifetime of the lock_guard 
    std::lock_guard<std::mutex> l(m); 

    // Now only a single thread can run this code 
    std::cout << i << ": "; 
    funcB(); 
    funcC(); 

    // As we exit this scope, the lock_guard is destroyed, 
    // the mutex is unlocked, and another thread is allowed to run 
} 

int main() { 
    std::vector<std::thread> vt; 

    // Create and launch a bunch of threads 
    for(int i =0; i < 10; i++) 
    vt.push_back(std::thread(funcA, i)); 

    // Wait for all of them to complete 
    for(auto& t : vt) 
    t.join(); 
} 

नोट्स:

• अपने उदाहरण में कुछ कोड funcA से संबंधित नहीं आह्वान सकता या तो funcB या funcC का सम्मान के बिना funcA सेट लॉक करें।
• आपके प्रोग्राम की संरचना के आधार पर, आप म्यूटेक्स के जीवनकाल को अलग-अलग प्रबंधित करना चाह सकते हैं। उदाहरण के तौर पर, यह कक्षा के वर्ग सदस्य बनना चाह सकता है जिसमें funcA शामिल है।

Answer 3

आप जीसीसी 4.7 उपयोग कर रहे हैं की तुलना में आप निम्न कार्य करना नई व्यवहार स्मृति सुविधा का उपयोग कर सकते हैं:

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

वर्तमान में, लेन-देन केवल लेनदेन विवरण, लेनदेन अभिव्यक्तियों और फ़ंक्शन लेनदेन के रूप में सी ++ और सी में समर्थित हैं। निम्न उदाहरण में, दोनों ए और बी पढ़ा जाएगा और अंतर ग लिखा जाएगा, सभी atomically और अन्य लेनदेन से अलग:

__transaction_atomic { c = a - b; } 

इसलिए, एक और धागा समवर्ती बिना ख अद्यतन करने के लिए निम्नलिखित कोड का उपयोग कर सकते कभी के कारण ग एक नकारात्मक मूल्य धारण करने के लिए (और इस तरह ताले या सी ++ 11 एटोमिक्स के रूप में अन्य तुल्यकालन निर्माणों का उपयोग किए बिना):

__transaction_atomic { if (a > b) b++; } 

लेन-देन की सटीक अर्थ विज्ञान सी ++ 11 के रूप में परिभाषित कर रहे हैं/सी 1 एक्स मेमोरी मॉडल (विनिर्देश के लिंक के लिए नीचे देखें)। असल में, लेन-देन सिंक्रनाइज़ेशन गारंटी प्रदान करते हैं जो सभी लेनदेन के लिए एक गार्ड के रूप में एक वैश्विक लॉक का उपयोग करते समय गारंटीकृत की जाएगी। ध्यान दें कि सी/सी ++ में अन्य सिंक्रनाइज़ेशन संरचनाओं की तरह, लेन-देन डेटा-रेस-फ्री प्रोग्राम पर भरोसा करते हैं (उदाहरण के लिए, एक नॉनट्रांसैक्शनल लिखना जो एक ही स्मृति स्थान पर एक लेनदेन पढ़ने के साथ समवर्ती है, एक डेटा रेस है)।

और जानकारी: http://gcc.gnu.org/wiki/TransactionalMemory