हमें सी # में लॉक करने और ऑब्जेक्ट करने की आवश्यकता क्यों है?

Question

यह ऐसा कुछ है जिसे मैंने कभी नहीं समझा है। यह लगभग उदाहरण

class Account 
{ 
    decimal balance; 
    private Object thisLock = new Object(); 

    public void Withdraw(decimal amount) 
    { 
     lock (thisLock) 
     { 
      if (amount > balance) 
      { 
       throw new Exception("Insufficient funds"); 
      } 
      balance -= amount; 
     } 
    } 
} 

https://msdn.microsoft.com/en-us/library/c5kehkcz.aspx से

की तरह, एक डमी उद्देश्य यह है कि lock एड हो जाता है बनाने के लिए एक हैक की तरह लगता है।

क्यों भाषा डिजाइनरों यह इतना है कि

class Account 
{ 
    decimal balance; 

    public void Withdraw(decimal amount) 
    { 
     lock 
     { 
      if (amount > balance) 
      { 
       throw new Exception("Insufficient funds"); 
      } 
      balance -= amount; 
     } 
    } 
} 

बराबर होगा नहीं कर सके?

Answer 1

lock पर उत्तीर्ण उदाहरण पर महत्वपूर्ण अनुभाग की पहचान करता है।

आपके पास अपने कोड में असंबद्ध महत्वपूर्ण अनुभाग हो सकते हैं, और प्रत्येक एक अलग ऑब्जेक्ट लॉक कर देगा। एक पैरामीटर रहित lock कथन आपके द्वारा सुझाए गए विकल्पों की पसंद कई महत्वपूर्ण वर्गों के बीच अंतर करने में सक्षम नहीं होगा।

संपादित

हालांकि यह स्पष्ट लग सकता है, यह देखते हुए कि हर एक हिस्से को दिए गए महत्वपूर्ण अनुभाग में प्रवेश के लिए बंद कर दिया वस्तु तक पहुंच होनी चाहिए की आवश्यकता होगी, के लायक है। तो lock कथन की तुलना में पहले और उसी दायरे में पहले मनमाने ढंग से उदाहरण बनाने की बात नहीं है।

Answer 2

मुझे लगता है कि लॉक कीवर्ड क्या कर रहा है में भ्रम है। यह केवल 1 धागा नहीं कह रहा है कोड के उस अनुभाग दर्ज कर सकते हैं लेकिन यह 2 बातें कह रहा है:

1. केवल एक धागा जो thisLock
2. किसी भी अन्य अनुभाग जिसके साथ thisLock है बंद कर दिया जाता है कोड के इस हिस्से में प्रवेश कर सकते इस थ्रेड को छोड़कर इस धागे को छोड़कर किसी भी थ्रेड द्वारा प्रविष्टि की अनुमति नहीं दी जाएगी।

जो आप सुझाव दे रहे हैं वह केवल पहला होगा लेकिन दोनों नहीं। इस उदाहरण को देखो:

class Account 
{ 
    decimal balance; 
    private Object thisLock = new Object(); 
    private Object thisLock2 = new Object(); 

    public void Withdraw(decimal amount) 
    { 
     lock (thisLock) 
     { 
      if (amount > balance) 
      { 
       throw new Exception("Insufficient funds"); 
      } 
      balance -= amount; 
     } 

     // more code here but no locking necessary... 

     lock(thisLock) 
     { 
      // only one thread can enter here who has thisLock 
     } 

     lock (thisLock2) 
     { 
      // If T1 (thread1) is working with thisLock, T2 can come here since it has nothing to do 
      // with thisLock. 
     } 
    } 

    public void AnotherOperation() 
    { 
     lock (thisLock) 
     { 
      // code here... 
     } 
    } 

    public void YetAnotherOperation() 
    { 
     lock (thisLock) 
     { 
      // code here... 
     } 
    } 
} 

एक धागा, का कहना है कि टी 1, पहले लॉक के साथ वापसी भाग कर रहा है, लॉक के साथ वर्ग (thisLock) के अन्य सभी वर्गों किसी अन्य धागे से प्रविष्टि के रूप में अच्छी तरह से की अनुमति नहीं है जब । हालांकि, इस लॉक 2 के साथ भाग को अन्य धागे द्वारा दर्ज करने की अनुमति है।

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