कंसूरेंसी <T> कंसुरेंसी

Question

के साथ सक्षम करने के लिए मेरे पिछले question है जो मैंने अपना समाधान प्रदान किया है; हालांकि, मेरे पास ConcurrentQueue<T> तक पहुंच नहीं है क्योंकि मैं नेट 3.5 पर हूं। समेकन की अनुमति देने के लिए मुझे Queue<T> की आवश्यकता है। मैंने यह question पढ़ा है और कतार में नहीं है और थ्रेडेड विधि किसी आइटम को निकालने का प्रयास करती है तो कोई समस्या उत्पन्न होती है।

मेरा कार्य अब यह निर्धारित करना है कि मैं अपनी समवर्ती कतार कक्षा प्राप्त कर सकता हूं या नहीं।

public sealed class ConcurrentQueue : Queue<DataTable> 
{ 
    public event EventHandler<TableQueuedEventArgs> TableQueued; 
    private ICollection que; 

    new public void Enqueue(DataTable Table) 
    { 
     lock (que.SyncRoot) 
     { 
      base.Enqueue(Table); 
     } 

     OnTableQueued(new TableQueuedEventArgs(Dequeue())); 
    } 

    // this is where I think I will have a problem... 
    new public DataTable Dequeue() 
    { 
     DataTable table; 

     lock (que.SyncRoot) 
     { 
      table = base.Dequeue(); 
     } 

     return table; 
    } 

    public void OnTableQueued(TableQueuedEventArgs table) 
    { 
     EventHandler<TableQueuedEventArgs> handler = TableQueued; 

     if (handler != null) 
     { 
      handler(this, table); 
     } 
    } 
} 

तो, जब एक DataTable कतारबद्ध है, EventArgs एक dequeued तालिका घटना ग्राहक के लिए पारित करेंगे: यह है कि मैं क्या के साथ आया है। क्या यह कार्यान्वयन मुझे थ्रेड-सुरक्षित कतार प्रदान करेगा?

Answer 1

आप अपनी वस्तुओं को रद्द कर रहे हैं जैसे आप उन्हें घेरते हैं।
आपको अपने पैरामीटर का उपयोग करके ईवेंट को बढ़ाने की आवश्यकता है।

चाहे यह वास्तव में थ्रेड-सुरक्षित है, आप इसका उपयोग कैसे करते हैं इस पर निर्भर करता है।
यदि आपने कभी Count चेक किया है या खालीपन की जांच करें, तो यह थ्रेडसेफ नहीं है और आसानी से थ्रेडसेफ नहीं बनाया जा सकता है।
यदि आप नहीं करते हैं, तो आप शायद कतार की तुलना में कुछ सरल उपयोग कर सकते हैं।

Answer 2

मेरे पसंदीदा खोज इंजन की त्वरित यात्रा से पता चला कि मेरी याददाश्त सही थी; you can get the Task Parallel Library even on .NET 3.5। System.Threading.dll वांछित प्राप्त करने के लिए The PFX team blog post on the subject और Reactive Extensions भी डाउनलोड करें जो आप डाउनलोड करते हैं।

Answer 3

लाइन OnTableQueued(new TableQueuedEventArgs(Dequeue())); में अपने Enqueue विधि में

उपयोग Peek बजाय विपंक्ति

यह

OnTableQueued(new TableQueuedEventArgs(base.Peek()));

Answer 4

सच है कि आप new उपयोग करने के लिए आधार से तरीकों को छिपाने के लिए की जरूरत होनी चाहिए कक्षा आमतौर पर एक संकेत है कि आपको विरासत के बजाय संरचना का उपयोग करना चाहिए ...

यहाँ एक सरल सिंक्रनाइज़ कतार है, जो विरासत का उपयोग नहीं करता है, लेकिन अभी भी मानक Queue<T> के व्यवहार पर निर्भर करता है:

public class ConcurrentQueue<T> : ICollection, IEnumerable<T> 
{ 
    private readonly Queue<T> _queue; 

    public ConcurrentQueue() 
    { 
     _queue = new Queue<T>(); 
    } 

    public IEnumerator<T> GetEnumerator() 
    { 
     lock (SyncRoot) 
     { 
      foreach (var item in _queue) 
      { 
       yield return item; 
      } 
     } 
    } 

    IEnumerator IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 

    public void CopyTo(Array array, int index) 
    { 
     lock (SyncRoot) 
     { 
      ((ICollection)_queue).CopyTo(array, index); 
     } 
    } 

    public int Count 
    { 
     get 
     { 
      // Assumed to be atomic, so locking is unnecessary 
      return _queue.Count; 
     } 
    } 

    public object SyncRoot 
    { 
     get { return ((ICollection)_queue).SyncRoot; } 
    } 

    public bool IsSynchronized 
    { 
     get { return true; } 
    } 

    public void Enqueue(T item) 
    { 
     lock (SyncRoot) 
     { 
      _queue.Enqueue(item); 
     } 
    } 

    public T Dequeue() 
    { 
     lock(SyncRoot) 
     { 
      return _queue.Dequeue(); 
     } 
    } 

    public T Peek() 
    { 
     lock (SyncRoot) 
     { 
      return _queue.Peek(); 
     } 
    } 

    public void Clear() 
    { 
     lock (SyncRoot) 
     { 
      _queue.Clear(); 
     } 
    } 
} 

Answer 5

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

internal sealed class LockFreeQueue<T> 
{ 
    private sealed class Node 
    { 
    public readonly T Item; 
    public Node Next; 
    public Node(T item) 
    { 
     Item = item; 
    } 
    } 
    private volatile Node _head; 
    private volatile Node _tail; 
    public LockFreeQueue() 
    { 
    _head = _tail = new Node(default(T)); 
    } 
#pragma warning disable 420 // volatile semantics not lost as only by-ref calls are interlocked 
    public void Enqueue(T item) 
    { 
    Node newNode = new Node(item); 
    for(;;) 
    { 
     Node curTail = _tail; 
     if (Interlocked.CompareExchange(ref curTail.Next, newNode, null) == null) //append to the tail if it is indeed the tail. 
     { 
     Interlocked.CompareExchange(ref _tail, newNode, curTail); //CAS in case we were assisted by an obstructed thread. 
     return; 
     } 
     else 
     { 
     Interlocked.CompareExchange(ref _tail, curTail.Next, curTail); //assist obstructing thread. 
     } 
    } 
    }  
    public bool TryDequeue(out T item) 
    { 
    for(;;) 
    { 
     Node curHead = _head; 
     Node curTail = _tail; 
     Node curHeadNext = curHead.Next; 
     if (curHead == curTail) 
     { 
     if (curHeadNext == null) 
     { 
      item = default(T); 
      return false; 
     } 
     else 
      Interlocked.CompareExchange(ref _tail, curHeadNext, curTail); // assist obstructing thread 
     } 
     else 
     { 
     item = curHeadNext.Item; 
     if (Interlocked.CompareExchange(ref _head, curHeadNext, curHead) == curHead) 
     { 
      return true; 
     } 
     } 
    } 
    } 
#pragma warning restore 420 
}