परमाणु रूप से कोड के ब्लॉक को निष्पादित

Question

आप निम्न प्रश्न का उत्तर कैसे देंगे?

जावा कक्षा की एक विधि में कोड का एक ब्लॉक होता है जो परमाणु रूप से निष्पादित होना चाहिए। के बारे में बताएं, उचित छद्म कोड का उपयोग कर आप कैसे सुनिश्चित करेगी कि कोड के इस ब्लॉक atomically निष्पादित किया जाता है

मैं विधि बनाकर इस लक्ष्य को हासिल होगा ..

public final AtomicInteger x = new AtomicInteger(0); 

तो get बयान लौटे सुनिश्चित :

x.get() 

और यदि मैं x के मान में वृद्धि करना चाहता हूं तो क्या मैं ऐसा करूंगा?

x.getAndIncrement(); 

Answer 1

जवाब "परमाणु" की अपनी परिभाषा

पर निर्भर करता है मैं atomic के लिए तीन मान्य परिभाषाओं के बारे में पता:

1. परमाणु के रूप में सिंक्रनाइज़: केवल एक ही धागे में से एक पर कोड को क्रियान्वित किया जा सकता है पहर;
2. परमाणु एसीआईडी ​​में: सभी क्रिया/ब्लॉक होता है, या इनमें से कोई भी नहीं करता है;
3. परमाणु अनियंत्रित के रूप में: एक बार जब ब्लॉक शुरू होता है, तो इसे कार्य स्विचिंग द्वारा भी बाधित नहीं किया जा सकता है।

पहला संभवतः आपके प्रोफेसर का क्या मतलब है, और यह पूरा करना आसान है (नीचे देखें)।

दूसरा (एसीआईडी ​​में परमाणु) का अनुमान लगाया जा सकता है। निचे देखो।

तीसरे स्थान पर जावा में गारंटी नहीं दी जा सकती है - यह अनियंत्रितता के लिए आवश्यक "महत्वपूर्ण खंड" प्राइमेटिव तक पहुंच प्रदान नहीं करती है। सौभाग्य से, इसकी आवश्यकता ऑपरेटिंग सिस्टम और डिवाइस ड्राइवरों तक काफी सीमित है।

परमाणु सिंक्रनाइज़

में के रूप में यह अपेक्षाकृत आसान है: बस एक तुल्यकालन ब्लॉक में कोड के अपने ब्लॉक संलग्न।मैं नीचे एक असतत ब्लॉक के रूप में यह दिखाया गया है, लेकिन वहाँ अन्य विकल्प हैं:

public void doSomethingQuasiAtomic() { 
    synchronized (exampleLock) { 
     // Your code block goes here. 
     // Only one thread will ever be in this block at a time. 
     ... 
    } 
} 

परमाणु एसिड

वहाँ ACID atomicity के लिए कोई सामान्य मामला समाधान है के रूप में, लेकिन यह अनुमान लगाया जा सकता, सिंक्रनाइज़ कोड का भी उपयोग कर रहे हैं। ऐसा करने के लिए, कार्रवाई के प्रत्येक भाग सुरक्षित रूप से उलटा होना चाहिए।

यह मैं इसे कैसे दृष्टिकोण होता है:

तर्क के लिए, वहाँ एक बहुखण्डीय कार्रवाई आप एक वस्तु हम exampleObj फोन करता हूँ पर क्या करने की जरूरत है, तो आप तीन कार्यों का प्रदर्शन किया जा करने के लिए है कि मान जो सुरक्षित रूप से उलट दिया जा सकता है, और example पर सभी पहुंच exampleLock पर सिंक्रनाइज़ की गई है।

    synchronized(exampleLock) { 
     boolean actionOneDone=false; 
     boolean actionTwoDone=false; 
     boolean actionThreeDone=false; 
     try { 
      actionOneDone=doActionOne(exampleObj); // or perhaps exampleObj.doActionOne(); 
      actionTwoDone=doActionTwo(exampleObj); 
      actionThreeDone=doActionThree(exampleObj); 
     } catch (Exception ex) { 
      // Whatever seems appropriate here. 
     } finally { 
      if (! (actionOneDone && actionTwoDone && actionThreeDone)) { 
       /* At least one part failed. Back out the completed actions in reverse order. 
       * Note that we never need to reverse action three since if it completed, so did the others. 
       */ 
       if (actionTwoDone) { 
        reverseActionTwo(exampleObj); // or perhaps exampleObj.reverseActionTwo(); 
       } 
       if (actionOneDone) { 
        reverseActionOne(exampleObj); 
       } 
      } 
     } 
    } 

Answer 2

मुझे विश्वास है कि उम्मीद जवाब कुछ इस तरह था:

public class A { 
    public void foo() { 
     // .. some code 
     doSomething(); // the critical part 
     // .. come code 
    } 

    public synchronized void doSomething() { // this is a synchronized method 
     // the critical code 
    } 
} 

doSomething() के निष्पादन वास्तव में परमाणु नहीं है (अस्वीकरण: यह atomicity से बहुत अलग है), लेकिन synchronized कीवर्ड सुनिश्चित कि केवल एक धागा इस विधि के निष्पादन में प्रवेश कर सकता है (A के एक उदाहरण पर)। मुझे लगता है कि वे परमाणु के बजाय उनका मतलब था।

Here जावा में परमाणु के बारे में एक और सवाल है। आपको वहां कुछ उपयोगी मिल सकता है।