जावा में पदानुक्रमित म्यूटेक्स ताले

Question

मैं एक फाइल सिस्टम पदानुक्रम के आधार पर लॉक करने में सक्षम होना चाहता हूं।

थ्रेड 1: उदाहरण के लिए:

lock("/"); 
doStuff(); 
unlock(); 

थ्रेड 2:

lock("/sub/foo"); 
doStuff(); 
unlock(); 

थ्रेड 3:

lock("/sub/bar"); 
doStuff(); 
unlock(); 

थ्रेड 1 पहले तो ताला प्राप्त कर लेता है, तो सूत्र 2 और 3 होगा थ्रेड 1 अनलॉक होने तक अवरुद्ध रहें। हालांकि, अगर थ्रेड 2 पहले लॉक प्राप्त करता है, तो थ्रेड 3 थ्रेड 2 के साथ एक ही समय में निष्पादित करने में सक्षम होना चाहिए। सामान्य नियम यह है कि यदि मूल निर्देशिका पर लॉक है, तो थ्रेड को ब्लॉक करना होगा।

क्या जावा में कुछ भी अंतर्निहित है जो इसे हल करने में मदद कर सकता है? मैं प्रति निर्देशिका लॉक को संग्रहित करना चाहता हूं क्योंकि सैकड़ों हजार निर्देशिकाएं होंगी। जब भी आप उस पेड़ आप जड़ से नीचे जाना में कुछ भी ताला और लक्ष्य के अलावा सब कुछ पर एक रीड-लॉक प्राप्त करने के लिए की जरूरत है

-/
- sub 
    - foo 
    - bar 

:

Answer 1

मैं इस तरह एक पेड़ में निर्देशिका पथ की दुकान करता हूँ खुद नोड। लक्ष्य नोड एक लेखन ताला मिलता है।

यह योजना आपको पेड़ के प्रासंगिक हिस्सों की डेडलॉक-स्वतंत्रता और स्थिरता की गारंटी देती है।

मुझे सैकड़ों हजारों ताले स्टोर करने में कोई विशेष समस्या नहीं दिखाई दे रही है। यह शायद प्रति लॉक 100 बाइट रैम बर्बाद करने जा रहा है। लेकिन यह वास्तुकला को सरल बनाता है। क्या आप वास्तव में एक समस्या है तो क्या आप मापते हैं?

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

Answer 2

एक और अधिक प्रदर्शन समाधान हो सकता है, लेकिन यहां मैं कैसे शुरू करूंगा।

मैं lock(path) और unlock(path) विधि के साथ एक साझा TreeAccess ऑब्जेक्ट बनाउंगा। इस विधि को एक सिंक्रनाइज़ ब्लॉक डालना होगा जो पथ उपलब्ध होने तक लूप होगा। प्रत्येक पुनरावृत्ति पर, यदि उपलब्ध नहीं है, तो यह जांच करेगा कि पथ उपलब्ध है या नहीं, और यदि नहीं, wait() कुछ अन्य थ्रेड notifyAll() पर कॉल करता है। यदि पथ उपलब्ध है, तो यह आगे बढ़ेगा, और जब पूरा हो जाए, तो अनलॉक() विधि को कॉल करें जो notifyAll() होगा।

आगे बढ़ने से पहले, आपको लॉक पथ को कुछ डेटा संरचना में संग्रहीत करना होगा। और सूचित करने से पहले, आपको इस डेटा संरचना से अनलॉक पथ को हटाना होगा। यह जांचने के लिए कि कोई पथ उपलब्ध है या नहीं, आपको यह पता लगाना होगा कि क्या इस डेटा संरचना में कुछ पथ मौजूद है जो बराबर है या जिस पथ को आप लॉक करना चाहते हैं उसका पूर्वजों है।

public void lock(String path) { 
    synchronized (lock) { 
     while (!available(path)) { 
      lock.wait(); 
     } 
     lockedPaths.add(path); 
    } 
} 

public void unlock(String path) { 
    synchronized (lock) { 
     lockedPaths.remove(path); 
     lock.notifAll(); 
    } 
} 

private boolean available(String path) { 
    for (String lockedPath : lockedPaths) { 
     if (isParentOrEqual(lockedPath, path) { // this method is left as an exercise 
      return false; 
     } 
    } 
    return true; 
}