消息队列问题！！！该何时读取？

Question

把消息写到队列中去后问题来了
取只能取一条，下一条什么时候取定时取？？？，能监听到队列吗，有的时候就取出来，没有就不取

Answer 1

开个后台线程一直取while(!exit)
{
    if (list.count > 0)
    {
       object item; //类型自定义
       lock(lockFlag)
       {
            item = list[0];
            list.Remove(item);
       }
       
       //do something
    }
    else
    {
        Thread.Sleep(500); //看具体的实时性要求
    ｝
}

Answer 2

监听也可以，可以通过事件方式来实现。比方：
定义一个类： ItemsManager
有： private List<Object> itemsList = new List<Object>();
定义事件 OnItemInput.
有公共函数：public void AddItem(object Item);
并在AddItem函数中触发OnItemInput事件。外部业务逻辑添加对OnItemInput的事件响应即可。（细节还有很多要注意，是同步还是异常等）

Answer 3

用阻塞队列    /// <summary>
    /// 阻塞队列类
    /// 注：线程类本身就是线程安全的。
    /// 但读空线程会出错
    /// </summary>
    /// <typeparam name="Type"></typeparam>
    public class BlockingQueue<Type>
    {
        private Queue<Type> m_queue = null;
        //定义信号量
        private Semaphore m_nBusy, m_nIdle;
        //定义出入队列锁
        private object m_inLock = new object(), m_outLock = new object();
        //默认队列长度（系统默认32）
        private const int m_queuelegth_const = 128;        public BlockingQueue(int maxCount)
        {
            m_queue = new Queue<Type>(maxCount);
            m_nBusy = new Semaphore(0, maxCount);
            m_nIdle = new Semaphore(maxCount, maxCount);
        }        public BlockingQueue()
        {
            m_queue = new Queue<Type>(m_queuelegth_const);
            m_nBusy = new Semaphore(0, m_queuelegth_const);
            m_nIdle = new Semaphore(m_queuelegth_const, m_queuelegth_const);
        }        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="item"></param>
        public void Enqueue(Type item)
        {
            lock (m_inLock)
            {
                m_nIdle.WaitOne();
                m_queue.Enqueue(item);
                m_nBusy.Release();
            }
        }        /// <summary>
        /// 出队
        /// </summary>
        /// <returns></returns>
        public Type Dequeue()
        {
            lock (m_outLock)
            {
                m_nBusy.WaitOne();
                Type item = m_queue.Dequeue();
                m_nIdle.Release();
                return item;
            }
        }        /// <summary>
        /// 入队有时限
        /// </summary>
        /// <param name="item">入队对象</param>
        /// <param name="outTime">超时毫秒数</param>
        /// <returns></returns>
        public bool EnqueueTime(Type item, int outTime)
        {
            lock (m_inLock)
            {
                if (m_nIdle.WaitOne(outTime, true))
                {
                    m_queue.Enqueue(item);
                    m_nBusy.Release();
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }        /// <summary>
        /// 出队有时限
        /// </summary>
        /// <param name="item">出队对象</param>
        /// <param name="outTime">超时毫秒数</param>
        /// <returns></returns>
        public bool DequeueTime(out Type item, int outTime)
        {
            lock (m_outLock)
            {
                if (m_nBusy.WaitOne(outTime, true))
                {
                    item = m_queue.Dequeue();
                    m_nIdle.Release();
                    return true;
                }
                else
                {
                    item = default(Type);
                    return false;
                }
            }
        }        public void Clear()
        {
            m_queue.Clear();
        }        /// <summary>
        /// 属性 队列内容长
        /// </summary>
        public int Count
        {
            get { return m_queue.Count; }
        }        /// <summary>
        /// 析构
        /// </summary>
        ~BlockingQueue()
        {
            m_inLock = null;
            m_outLock = null;
            m_nBusy.Close();
            m_nIdle.Close();
            m_queue.Clear();
            m_queue = null;
        }
    }

Answer 4

听过用阻塞来循环读队列，但没太明白怎么操作，上面的代码没太看懂，能大概讲个原理吗？我是用asp.net写入队列，再用应用程序来读，如果没有队列就阻塞线程，那有队列又怎么通知它继续循环呢

Answer 5

你看阻塞队列读对象方法中的waitone就知道了，那是等待一个信号量释放。程序会阻塞在这里，信号量被别的线程释放后。这个线程的阻塞点会自动得到信号量资源继续下去。不用你去判断，请再参看些关于信号量和阻塞概念的书。