अधिक से अधिक तुलना और स्वैप

Question

शीर्षक के रूप में, मैं एक तुलना और स्वैप लागू करने के लिए देख रहा हूँ पता चलता है, लेकिन साथ अधिक से अधिक तुलना:

if(newValue > oldValue) { 
    oldValue = newValue; 
} 

जहां oldValue कुछ वैश्विक साझा राज्य है क्योंकि मैं एक गैर अवरुद्ध समाधान चाहते हैं

synchronized(locker) { 
    if(newValue > oldValue) { 
     oldValue = newValue; 
    }  
} 

: और newValue प्रत्येक थ्रेड के लिए निजी है, ऐसा किए बिना। अन्य गैर अवरुद्ध आपरेशन के स्रोत कोड का अध्ययन से, मैं (यह मानते हुए मान पूर्णांक हैं) इस के साथ आ गया है:

AtomicInteger oldValue; // shared global variable 

... 

public boolean GreaterThanCAS(int newValue) { 

    while(true) { 
     int local = oldValue; 
     if(local == oldValue) { 
      if(newValue > local) { 
       if(oldValue.compareAndSet(local, newValue) { 
        return true; // swap successful 
       } // else keep looping 
      } else { 
       return false; // swap failed 
      } 
     } // else keep looping 
    } 
} 

जब // else keep looping होता है, इसका मतलब है कि एक और धागा बदल गया है इस बीच में oldValue और इसलिए मुझे लूप करने की ज़रूरत है और पुनः प्रयास करें।

क्या यह कार्यान्वयन सही है (धागा-सुरक्षित)?

Answer 1

मुझे आपके कार्यान्वयन के साथ कोई समस्या नहीं दिखाई देती है, बशर्ते कि कोई धागा कभी भी AtomicInteger के मान को कम न करे। यदि वे करते हैं, तो आपका कोड दौड़ की स्थिति के लिए खुला है।

नोट के रूप में इस कोड को सरल बनाया जा सकता है कि: एक से अधिक जांच बेमानी है पहले

while(true) { 
    int local = oldValue.get(); 
    if(newValue > local){ 
     if(oldValue.compareAndSwap(local, newValue) { 
       return true; // swap successful 
     } // else keep looping 
    }else 
     return false; 
} 

तुल्यता की जांच:

public boolean GreaterThanCAS(int newValue) { 
    while(true) { 
     int local = oldValue.get(); 
     if(newValue <= local) { 
      return false; // swap failed 
     } 
     if(oldValue.compareAndSet(local, newValue)) { 
      return true; // swap successful 
     } 
     // keep trying 
    } 
} 

Answer 2

मैं इसे लिखने और अधिक की तरह लग रहे करने के लिए फिर से होगा।

अन्यथा इसे ठीक काम करना चाहिए।

Answer 3

जावा 8 के बाद से इस updateAndGet के उपयोग के साथ सरल किया जा सकता:

public boolean greaterThanCAS(int newValue) { 
    return oldValue.updateAndGet(x -> x < newValue ? newValue : x) == newValue; 
} 

ध्यान दें कि यह सच भी वापसी होगी मामले में जब पुराने और नए मूल्यों बराबर हैं। यदि यह वांछित व्यवहार नहीं है तो @Adam's answer पर आज़माएं।

Answer 4

@ वाडज़िम, मैंने आपकी पोस्ट पर टिप्पणी की होगी, लेकिन स्टैक ओवरफ्लो का कहना है कि मेरे पास टिप्पणियां पोस्ट करने के लिए पर्याप्त अंक नहीं हैं। आपका उत्तर लगभग सही है, लेकिन आपका फ़ंक्शन हमेशा झूठा वापस आ जाएगा क्योंकि getAndUpdate हमेशा आपके मान में पिछले मान, या 'x' देता है। मुझे लगता है कि तुम सब करने की आवश्यकता होगी की जगह है अपने पिछले '==' के साथ '<', जैसे:

// return true if the assignment was made, false otherwise 
public boolean greaterThanCAS(int newValue) { 
    return oldValue.getAndUpdate(x -> x < newValue ? newValue : x) < newValue; 
}