सेमेफोर किस प्रकार और क्यों शुरू कर सकता है उससे अधिक परमिट देता है?

Question

मैं प्रैक्टिस में जावा कंसुरेंसी पुस्तक पढ़ रहा हूं। java.util.concurrent.Semaphore के बारे में एक अनुभाग में, नीचे दी गई पंक्तियां पुस्तक में मौजूद हैं। यह "आभासी परमिट 'की इसके कार्यान्वयन के बारे में एक टिप्पणी वस्तुओं

कार्यान्वयन कोई वास्तविक परमिट वस्तुओं है, और Semaphore धागे के साथ समाप्त परमिट, तो एक परमिट एक थ्रेड में अधिग्रहण से जारी कर सकते हैं संबद्ध नहीं करता जा एक और धागा आप बनाने जैसा एक परमिट और release लेने के रूप में acquire के बारे में सोच सकते हैं; एक Semaphore परमिट इसके साथ बनाया गया था की संख्या तक सीमित नहीं है।

क्या कोई इसे समझा सकता है? मुझे यह समझने में परेशानी हो रही है। यदि हम निश्चित आकार का पूल बनाते हैं, तो हम "परमिट" की एक निश्चित संख्या बनाते हैं। उपर्युक्त कथन से, ऐसा लगता है कि "परमिट" बढ़ते रह सकते हैं। इस तरह से डिजाइन क्यों किया गया है?

Answer 1

परमिट वस्तुओं "बाहर सौंपने" के बजाय

, कार्यान्वयन सिर्फ एक काउंटर है। जब एक नया परमिट "बनाया गया" काउंटर बढ़ जाता है, जब परमिट "लौटाया जाता है" काउंटर कम हो जाता है।

यह वास्तविक वस्तुओं हर समय बनाने की तुलना में बेहतर प्रदर्शन के लिए बनाता है।

ट्रेडऑफ यह है कि सेमफोर स्वयं कुछ प्रकार की प्रोग्रामिंग त्रुटियों (जैसे अनधिकृत परमिट कैश-इन्स, या सेमफोर लीक) का पता नहीं लगा सकता है। कोडर के रूप में, आपको अपने नियमों का पालन करना सुनिश्चित करना होगा।

Answer 2

क्या कोई इसे समझा सकता है? उपर्युक्त कथन से, ऐसा लगता है कि "परमिट" बढ़ते रह सकते हैं।

एक सेमफोर परमिट का एक काउंटर है। अधिग्रहण कमी की तरह है जो शून्य से नीचे जाने की बजाय प्रतीक्षा करता है। इसकी कोई ऊपरी सीमा नहीं है।

यह इस तरह से डिज़ाइन क्यों किया गया है?

क्योंकि ऐसा करना आसान है।

Answer 3

मुझे लगता है कि यह बार के रूप में कई बार हम "अतिरिक्त" प्लस जारी किया है और परमिट इसके साथ बनाया है कि हम क्या सेमाफोर की आवश्यकता हो सकती है।

जैसे:

Semaphore s = new Semaphore(1); // one permit when initialize 

s.acquire(); 
s.release(); 

s.release(); // "extra" release. 

इस समय, इस सेमाफोर की अनुमति देता है एक परमिट मूल रूप से और एक "अतिरिक्त" परमिट

Answer 4

शायद अंतिम पंक्ति "एक सेमाफोर परमिट की संख्या तक सीमित नहीं है यह "भ्रम का स्रोत है" के साथ बनाया गया था।

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

इसका अर्थ यह है कि उद्धृत रेखा (जेसीआईपी से) यह है: सबसे पहले, सेमेफोर कैसे काम करता है, परमिट जारी करने और प्राप्त करने के विवरण तक ही सीमित नहीं है - यह इस तथ्य में प्रकट होता है कि कोई भी धागा सेमफोर तक पहुंचने पर परमिट जारी किया जा सकता है (भले ही इस धागे के पास पहली जगह परमिट नहीं है)

दूसरा, आप reducePermits(int) विधि को कॉल करके - सेमफोर के अधिकतम परमिट को गतिशील रूप से कम कर सकते हैं।

Answer 5

पहली पोस्ट में उल्लेख किया

हर कॉल .release करने के लिए "सेमाफोर परमिट यह साथ बनाया गया था की संख्या तक सीमित नहीं है"() API एक के बाद परमिट गिनती में वृद्धि होगी। तो सेमफोरस में एक निश्चित परमिट आकार नहीं है

Answer 6

हम में से कुछ के लिए यह आश्चर्यजनक है।

आप आसानी से एक बाध्य सेमफोर उपclass कर सकते हैं।

/** 
* Terrible performance bounded semaphore. 
**/ 
public class BoundedSemaphore extends Semaphore { 
    private static final long serialVersionUID = -570124236163243243L; 
    final int bound; 
    public BoundedSemaphore(int permits) { 
     super(permits); 
     bound=permits; 
    } 

    @Override 
    synchronized public void acquire() throws InterruptedException { 
     super.acquire(); 
    } 

    @Override 
    synchronized public boolean tryAcquire() { 
     return super.tryAcquire(); 
    } 

    @Override 
    synchronized public void release() { 
     if(availablePermits()<bound){ 
      super.release(); 
     } 
    } 
    @Override 
    synchronized public void acquire(int count) throws InterruptedException { 
     super.acquire(count); 
    } 

    @Override 
    synchronized public boolean tryAcquire(int count) { 
     return super.tryAcquire(count); 
    } 

    @Override 
    synchronized public void release(int count) { 
     if(availablePermits()<bound){ 
      super.release(bound-availablePermits()); 
     } 
    } 
}