क्या .NET के लिए कोई सामान्य उद्देश्य ऑब्जेक्ट पूल है?

Question

मेरे पास समय और स्मृति के मामले में निर्माण करने के लिए महंगी कक्षा है। मैं इन चीजों का एक पूल बनाए रखना चाहता हूं और उसी प्रक्रिया में कई धागे की मांग पर उन्हें बाहर भेजना चाहता हूं।

क्या कोई सामान्य उद्देश्य ऑब्जेक्ट पूल है जो पहले से ही परीक्षण और साबित हुआ है? (मुझे COM + पूलिंग नहीं चाहिए।)

Answer 1

नहीं Cheeso, वहाँ इस तरह कोई सामान्य वस्तु पूल है। लेकिन यह एक अच्छा विचार है। मुझे लगता है कि यह विकसित करना बहुत आसान होगा। मुख्य बात यह एक थ्रेडेड वातावरण में अच्छी तरह से काम कर रही है।

मुझे लगता है कि यह एक दिलचस्प डिजाइन समस्या है।

1. वस्तुओं के लिए एक केन्द्रीय पूल रखें: उदाहरण के लिए, इस Sever वर्ग हार्डवेयर -और- आप indivudual धागे वस्तुओं अक्सर तो आप यह कर सकता है दे देंगे पर पैमाने पर करने की जरूरत है, तो।
2. प्रति थ्रेड पूल (एक कैश) रखें जो पॉप्युलेट होता है जब इसे थ्रेड के लिए पहली बार बुलाया जाता है, और जब यह खाली हो जाता है।

इस तरह, आप अधिकांश अनुरोधों के लिए प्रति-थ्रेड विवाद से बचते हैं।

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

यदि आप कक्षा या इंटरफ़ेस को सही तरीके से डिज़ाइन करते हैं, तो आप अधिक जटिल परिदृश्यों को संभालने के लिए समय के साथ कार्यान्वयन को बदल सकते हैं।

Answer 2

क्यों न केवल एक सिंगलटन लिखें जो केवल बनाई गई वस्तुओं की सरणी के प्रवेश द्वार के रूप में कार्य करता है।

जब कोई ऑब्जेक्ट सौंप दिया जाता है, तो उसे उपलब्ध सूची से हटा दें, इसे चेक आउट सूची में रखें, और फिर जब इसे वापस किया जाए, तो उसे उलट दें।

इसके लिए एक सिंगलटन का उपयोग करके आपके पास कॉल करने के लिए एक स्थिर वर्ग है, और यदि महंगी कक्षा सिंगलटन का एक आंतरिक वर्ग है, तो कुछ और महंगा वर्ग नहीं बना सकता है, और आप कितनी वस्तुओं को नियंत्रित कर सकते हैं आसानी से बनाएँ।

Answer 3

MSDN से सीधे कर लिया जाता है, यहाँ .NET 4 में नए समवर्ती संग्रह प्रकारों में से एक का उपयोग करने का एक उदाहरण है:

निम्न उदाहरण दर्शाता है कि कैसे अपने समर्थन की दुकान के रूप में एक System.Collections.Concurrent.ConcurrentBag<T> के साथ एक वस्तु पूल लागू करने के लिए।

public class ObjectPool<T> 
{ 
    private ConcurrentBag<T> _objects; 
    private Func<T> _objectGenerator; 

    public ObjectPool(Func<T> objectGenerator) 
    { 
     if (objectGenerator == null) 
      throw new ArgumentNullException("objectGenerator"); 
     _objects = new ConcurrentBag<T>(); 
     _objectGenerator = objectGenerator; 
    } 

    public T GetObject() 
    { 
     T item; 
     if (_objects.TryTake(out item)) 
      return item; 
     return _objectGenerator(); 
    } 

    public void PutObject(T item) 
    { 
     _objects.Add(item); 
    } 
} 

Answer 4

280Z28 द्वारा प्रस्तावित ऑब्जेक्टपूल क्लास बहुत अच्छा दिखता है। आप एक और कक्षा बनाने पर भी विचार कर सकते हैं जो IDISposable लागू करता है और GetObject() के वापसी मूल्य को लपेटता है। यह सुनिश्चित करेगा कि वस्तुओं को आपके पूल में वापस कर दिया गया है और अच्छी तरह से पढ़ता है:

class ObjectPoolReference<T> : IDisposable 
{ 
    public ObjectPool<T> Pool { get; private set; } 

    public T Instance { get; private set; } 

    public ObjectPoolReference(ObjectPool<T> pool, T instance) 
    { 
     Pool = pool; 
     Instance = instance; 
    } 

    ~ObjectPoolReference() 
    { 
     Dispose(); 
    } 

    #region IDisposable Members 

    private bool _Disposed = false; 

    public void Dispose() 
    { 
     if (!_Disposed) 
     { 
      Pool.PutObject(Instance); 

      _Disposed = true; 
     } 
    } 

    #endregion 
} 

//instance of the pool 
ObjectPool<Foo> Pool; 

//"using" ensures the reference is disposed at the end of the block, releasing the object back to the pool 
using (var Ref = Pool.GetObject()) 
{ 
    Ref.Instance.DoSomething(); 
} 

Answer 5

बस साझा करने के लिए। मैंने अपाचे कॉमन पूल का उपयोग मॉडल के रूप में एक जेनेरिक .NET सामान्य पूल लाइब्रेरी बनाई है। http://cobrary.wordpress.com/net-common-pool-library/