BlockingQueue.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using MyCaffe.basecode;
 
namespace MyCaffe.common
{
    public class BlockingQueue<T> : IDisposable 
    {
        CancelEvent m_evtCancel;
        ManualResetEvent m_evtReady = new ManualResetEvent(false);
        ManualResetEvent m_evtAbort = new ManualResetEvent(false);
        object m_syncObj = new object();
        List<T> m_rgData = new List<T>();
        int m_nDataCount = 0;
 
        public BlockingQueue(CancelEvent evtCancel)
        {
            m_evtCancel = evtCancel;
        }
 
        public void Reset()
        {
            m_evtAbort.Reset();
        }
 
        public void Abort()
        {
            m_evtAbort.Set();
        }
 
        public int Count
        {
            get { return m_nDataCount; }
        }
 
        public bool GetAt(int nIdx, ref T t)
        {
            while (Count <= nIdx)
            {
                if (m_evtCancel == null)
                    return false;
 
                WaitHandle[] rghCancel = m_evtCancel.Handles;
 
                if (m_evtReady == null || m_evtAbort == null)
                    return false;
 
                ManualResetEvent evtReady = m_evtReady;
                ManualResetEvent evtAbort = m_evtAbort;
 
                List<WaitHandle> rgWait = new List<WaitHandle>();
                rgWait.AddRange(rghCancel);
                rgWait.Add(evtAbort);
                rgWait.Add(evtReady);
 
                int nWait = WaitHandle.WaitAny(rgWait.ToArray());
                if (nWait < rgWait.Count - 1)
                {
                    evtAbort.Reset();
                    return false;
                }
 
                evtReady.Reset();
            }
 
            lock (m_syncObj)
            {
                t = m_rgData[nIdx];
                return true;
            }
        }
 
        public void Clear()
        {
            lock (m_syncObj)
            {
                m_rgData.Clear();
                m_nDataCount = 0;             
            }
        }
 
        public void Push(T t)
        {
            lock (m_syncObj)
            {
                if (m_evtReady != null)
                {
                    m_rgData.Add(t);
                    m_nDataCount = m_rgData.Count;
                    m_evtReady.Set();
                }
            }
        }
 
        public bool Pop(ref T t)
        {
            while (Count == 0)
            {
                WaitHandle[] rghCancel = m_evtCancel.Handles;
 
                if (m_evtCancel == null || m_evtAbort == null)
                    return false;
 
                ManualResetEvent evtAbort = m_evtAbort;
                ManualResetEvent evtReady = m_evtReady;
 
                List<WaitHandle> rgWait = new List<WaitHandle>();
                rgWait.AddRange(rghCancel);
                rgWait.Add(evtAbort);
                rgWait.Add(evtReady);
 
                int nWait = WaitHandle.WaitAny(rgWait.ToArray());
                if (nWait < rgWait.Count - 1)
                    return false;
 
                evtReady.Reset();
            }
 
            lock (m_syncObj)
            {
                t = m_rgData[0];
                m_rgData.RemoveAt(0);
                m_nDataCount = m_rgData.Count;
                return true;
            }
        }
 
        public bool Peek(ref T t)
        {
            while (Count == 0)
            {
                if (m_evtReady == null)
                    return false;
 
                if (m_evtCancel.WaitOne(0))
                    return false;
 
                Thread.Sleep(0);
            }
 
            lock (m_syncObj)
            {
                t = m_rgData[0];
                return true;
            }
        }
 
        protected virtual void Dispose(bool bDisposing)
        {
            if (m_evtAbort != null)
            {
                m_evtAbort.Set();
                Thread.Sleep(50);
                m_evtAbort.Dispose();
                m_evtAbort = null;
            }
 
            if (m_evtReady != null)
            {
                m_evtReady.Dispose();
                m_evtReady = null;
            }
 
            Clear();
        }
 
        public void Dispose()
        {
            Dispose(true);
        }
    }
}