自已动手做高性能消息队列

前言

        本人觉得码农的技术提升应该是从how to do到why do，而项目或产品都是从why do到how to do，按题来，所以呢下面先从大的方面介绍一下消息队列。

        消息队列是分布式高并发面目中必不可少的一部分，随着互联网、云计算、大数据的使用，消息队列的应用越来越多，消息队列在系统的可伸缩性、稳定性、提升吞吐量等方面有着显著的作用；它主要的作用一般如下：

       1.通过异步处理提高系统性能

 

        如上图，在不使用消息队列服务器的时候，用户的请求数据直接写入数据库，在高并发的情况下数据库压力剧增，使得响应速度变慢。但是在使用消息队列之后，用户的请求数据发送给消息队列之后立即 返回，再由消息队列的消费者进程从消息队列中获取数据，异步写入数据库。由于消息队列服务器处理速度快于数据库（消息队列也比数据库有更好的伸缩性），因此响应速度得到大幅改善。

        通过以上分析我们可以得出消息队列具有很好的削峰作用的功能——即通过异步处理，将短时间高并发产生的事务消息存储在消息队列中，从而削平高峰期的并发事务。 举例：在电子商务一些秒杀、促销活动中，合理使用消息队列可以有效抵御促销活动刚开始大量订单涌入对系统的冲击。如下图所示：

 

        因为用户请求数据写入消息队列之后就立即返回给用户了，但是请求数据在后续的业务校验、写数据库等操作中可能失败。因此使用消息队列进行异步处理之后，需要适当修改业务流程进行配合，比如用户在提交订单之后，订单数据写入消息队列，不能立即返回用户订单提交成功，需要在消息队列的订单消费者进程真正处理完该订单之后，甚至出库后，再通过电子邮件或短信通知用户订单成功，以免交易纠纷。这就类似我们平时手机订火车票和电影票。

       2.降低系统耦合性

        我们知道模块分布式部署以后聚合方式通常有两种：1.分布式消息队列和2.分布式服务。先来简单说一下分布式服务：目前使用比较多的用来构建SOA（Service Oriented Architecture面向服务体系结构）的分布式服务框架是阿里巴巴开源的Dubbo.如果想深入了解Dubbo的可以看我写的关于Dubbo的这一篇文章：《高性能优秀的服务框架-dubbo介绍》：https://juejin.im/post/5acadeb1f265da2375072f9c 再来谈我们的分布式消息队列：我们知道如果模块之间不存在直接调用，那么新增模块或者修改模块就对其他模块影响较小，这样系统的可扩展性无疑更好一些。

        我们最常见的事件驱动架构类似生产者消费者模式，在大型网站中通常用利用消息队列实现事件驱动结构。如下图所示：

 

        消息队列使利用发布-订阅模式工作，消息发送者（生产者）发布消息，一个或多个消息接受者（消费者）订阅消息。 从上图可以看到消息发送者（生产者）和消息接受者（消费者）之间没有直接耦合，消息发送者将消息发送至分布式消息队列即结束对消息的处理，消息接受者从分布式消息队列获取该消息后进行后续处理，并不需要知道该消息从何而来。对新增业务，只要对该类消息感兴趣，即可订阅该消息，对原有系统和业务没有任何影响，从而实现网站业务的可扩展性设计。

        消息接受者对消息进行过滤、处理、包装后，构造成一个新的消息类型，将消息继续发送出去，等待其他消息接受者订阅该消息。因此基于事件（消息对象）驱动的业务架构可以是一系列流程。

        另外为了避免消息队列服务器宕机造成消息丢失，会将成功发送到消息队列的消息存储在消息生产者服务器上，等消息真正被消费者服务器处理后才删除消息。在消息队列服务器宕机后，生产者服务器会选择分布式消息队列服务器集群中的其他服务器发布消息。

        前面说了这么多消息队列的重要性、使用场景、工作模式，有很多人就可能会说了，现有的ActiveMQ、RabbitMQ、Kafka、RocketMQ等多了去了，那在项目架构的时候选一个用上去就不行了，完全没有必要重复造轮子啊！本人认为对于重复造轮子的事情和其它任何事情都是一样的——任何事情没有绝对的好处或者坏处，比如是刚入门的码农、又或者很急的项目，完全可以选用现有一种通用的、成熟的产品，没必要去从零开始做；实际上没有任何一个优秀的产品全部使用三方的产品来组装完成的，任何一个好一点的项目发展到一定的时候都不约而同的进行底层开发。原因很简单：第一个任何通用型的产品总用功能覆盖不到的场景；第二个任何通用型的产品为了实现通用必将做了一些性能或架构的牺牲；现在道理都讲完了，开始动手了（都听你逼半天，能动手就尽量少逼逼！）。

 概述

　　动手前先构思一下，本人需要一个简单的、可发布订阅的、高吞吐量的消息队列，并将之简单大的方面分成QServer、QClient；QServer主要有Exchange、Binding、MessageQueue构成；QClient和QServer共用一套相同的传输编解码器QCoder ，主要实现Publish、Subscribe、Unsubcribe、Closes等功能；先想这么多，开干！

Exchange

　　主要在QServer中提供发布、订阅、连接、队列信息等管理

/****************************************************************************
*Copyright (c) 2018 Microsoft All Rights Reserved.
*CLR版本： 4.0.30319.42000
*机器名称：WENLI-PC
*公司名称：Microsoft
*命名空间：SAEA.QueueSocket.Model
*文件名： Exchange
*版本号： V1.0.0.0
*唯一标识：6a576aad-edcc-446d-b7e5-561a622549bf
*当前的用户域：WENLI-PC
*创建人： yswenli
*电子邮箱：wenguoli_520@qq.com
*创建时间：2018/3/5 16:36:44
*描述：
*
*=====================================================================
*修改标记
*修改时间：2018/3/5 16:36:44
*修改人： yswenli
*版本号： V1.0.0.0
*描述：
*
*****************************************************************************/

using SAEA.Commom;
using SAEA.Sockets.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SAEA.QueueSocket.Model
{
    class Exchange : ISyncBase
    {
        object _syncLocker = new object();

        public object SyncLocker
        {
            get
            {
                return _syncLocker;
            }
        }

        long _pNum = 0;

        long _cNum = 0;

        long _inNum = 0;

        long _outNum = 0;

        private Binding _binding;

        private MessageQueue _messageQueue;

        public Exchange()
        {
            this._binding = new Binding();

            this._messageQueue = new MessageQueue();
        }


        public void AcceptPublish(string sessionID, QueueResult pInfo)
        {
            lock (_syncLocker)
            {
                this._binding.Set(sessionID, pInfo.Name, pInfo.Topic);

                this._messageQueue.Enqueue(pInfo.Topic, pInfo.Data);

                _pNum = this._binding.GetPublisherCount();

                Interlocked.Increment(ref _inNum);
            }
        }

        public void AcceptPublishForBatch(string sessionID, QueueResult[] datas)
        {
            if (datas != null)
            {
                foreach (var data in datas)
                {
                    if (data != null)
                    {
                        AcceptPublish(sessionID, data);
                    }
                }
            }
        }


        public void GetSubscribeData(string sessionID, QueueResult sInfo, int maxSize = 500, int maxTime = 500, Action<List<string>> callBack = null)
        {
            lock (_syncLocker)
            {
                var result = this._binding.GetBingInfo(sInfo);

                if (result == null)
                {
                    this._binding.Set(sessionID, sInfo.Name, sInfo.Topic, false);

                    _cNum = this._binding.GetSubscriberCount();

                    Task.Factory.StartNew(() =>
                    {
                        while (this._binding.Exists(sInfo))
                        {
                            var list = this._messageQueue.DequeueForList(sInfo.Topic, maxSize, maxTime);
                            if (list != null)
                            {
                                list.ForEach(i => { Interlocked.Increment(ref _outNum); });
                                callBack?.Invoke(list);
                                list.Clear();
                                list = null;
                            }
                        }
                    });
                }
            }            
        }

        public void Unsubscribe(QueueResult sInfo)
        {
            Interlocked.Decrement(ref _cNum);
            this._binding.Del(sInfo.Name, sInfo.Topic);
        }

        public void Clear(string sessionID)
        {
            lock (_syncLocker)
            {
                var data = this._binding.GetBingInfo(sessionID);

                if (data != null)
                {
                    if (data.Flag)
                    {
                        Interlocked.Decrement(ref _pNum);
                    }
                    else
                    {
                        Interlocked.Decrement(ref _cNum);
                    }
                    this._binding.Remove(sessionID);
                }
            }
        }

        public Tuple<long, long, long, long> GetConnectInfo()
        {
            return new Tuple<long, long, long, long>(_pNum, _cNum, _inNum, _outNum);
        }

        public List<Tuple<string, long>> GetQueueInfo()
        {
            List<Tuple<string, long>> result = new List<Tuple<string, long>>();
            lock (_syncLocker)
            {
                var list = this._messageQueue.ToList();
                if (list != null)
                {
                    var tlts = list.Select(b => b.Topic).Distinct().ToList();

                    if (tlts != null)
                    {
                        foreach (var topic in tlts)
                        {
                            var count = this._messageQueue.GetCount(topic);
                            var t = new Tuple<string, long>(topic, count);
                            result.Add(t);
                        }
                        tlts.Clear();
                    }
                    list.Clear();
                }
            }
            return result;
        }

    }
}

　　思维发散：这里可以增加全局消息队列、指定连接消息队列等；将连接通过类型redis cluster模式进行一个均衡分布等

Binding

　　主要功能是将连接、主题进行映射管理

/****************************************************************************
*Copyright (c) 2018 Microsoft All Rights Reserved.
*CLR版本： 4.0.30319.42000
*机器名称：WENLI-PC
*公司名称：Microsoft
*命名空间：SAEA.QueueSocket.Model
*文件名： Binding
*版本号： V1.0.0.0
*唯一标识：7472dabd-1b6a-4ffe-b19f-2d1cf7348766
*当前的用户域：WENLI-PC
*创建人： yswenli
*电子邮箱：wenguoli_520@qq.com
*创建时间：2018/3/5 17:10:19
*描述：
*
*=====================================================================
*修改标记
*修改时间：2018/3/5 17:10:19
*修改人： yswenli
*版本号： V1.0.0.0
*描述：
*
*****************************************************************************/

using SAEA.Commom;
using SAEA.Sockets.Interface;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace SAEA.QueueSocket.Model
{
    /// <summary>
    /// 连接与主题的映射
    /// </summary>
    class Binding : ISyncBase, IDisposable
    {
        List<BindInfo> _list = new List<BindInfo>();

        object _syncLocker = new object();

        public object SyncLocker
        {
            get
            {
                return _syncLocker;
            }
        }

        bool _isDisposed = false;

        int _minutes = 10;

        public Binding(int minutes = 10)
        {
            _minutes = minutes;

            ThreadHelper.PulseAction(() =>
            {
                lock (_syncLocker)
                {
                    var list = _list.Where(b => b.Expired <= DateTimeHelper.Now).ToList();
                    if (list != null)
                    {
                        list.ForEach(item =>
                        {
                            _list.Remove(item);
                        });
                        list.Clear();
                        list = null;
                    }
                }
            }, new TimeSpan(0, 0, 10), _isDisposed);
        }


        public void Set(string sessionID, string name, string topic, bool isPublisher = true)
        {

            lock (_syncLocker)
            {
                var result = _list.FirstOrDefault(b => b.Name == name && b.Topic == topic);
                if (result == null)
                {
                    _list.Add(new BindInfo()
                    {
                        SessionID = sessionID,
                        Name = name,
                        Topic = topic,
                        Flag = isPublisher,
                        Expired = DateTimeHelper.Now.AddMinutes(_minutes)
                    });
                }
                else
                {
                    result.Expired = DateTimeHelper.Now.AddMinutes(_minutes);
                }
            }
        }

        public void Del(string sessionID, string topic)
        {
            lock (_syncLocker)
            {
                var result = _list.FirstOrDefault(b => b.Name == sessionID && b.Topic == topic);
                if (result != null)
                {
                    _list.Remove(result);
                }
            }
        }

        public void Remove(string sessionID)
        {
            lock (_syncLocker)
            {
                var result = _list.Where(b => b.SessionID == sessionID).ToList();
                if (result != null)
                {
                    result.ForEach((item) =>
                    {
                        _list.Remove(item);
                    });
                    result.Clear();
                }
            }
        }

        public BindInfo GetBingInfo(QueueResult sInfo)
        {
            lock (_syncLocker)
            {
                var bi = _list.FirstOrDefault(b => b.Name == sInfo.Name && b.Topic == sInfo.Topic);

                if (bi != null)
                {
                    if (bi.Expired <= DateTimeHelper.Now)
                    {
                        Remove(bi.SessionID);
                    }
                    else
                    {
                        return bi;
                    }
                }
                return null;
            }
        }

        public BindInfo GetBingInfo(string sessionID)
        {
            lock (_syncLocker)
            {
                return _list.FirstOrDefault(b => b.SessionID == sessionID);
            }
        }

        public bool Exists(QueueResult sInfo)
        {
            lock (_syncLocker)
            {
                var data = _list.FirstOrDefault(b => b.Name == sInfo.Name && b.Topic == sInfo.Topic);

                if (data != null)
                {
                    if (data.Expired <= DateTimeHelper.Now)
                    {
                        Remove(data.SessionID);

                        return false;
                    }

                    data.Expired = DateTimeHelper.Now.AddMinutes(_minutes);

                    return true;
                }
            }
            return false;
        }


        public IEnumerable<BindInfo> GetPublisher()
        {
            lock (_syncLocker)
            {
                return _list.Where(b => b.Flag);
            }
        }

        public int GetPublisherCount()
        {
            lock (_syncLocker)
            {
                return _list.Where(b => b.Flag).Count();
            }
        }

        public IEnumerable<BindInfo> GetSubscriber()
        {
            lock (_syncLocker)
            {
                return _list.Where(b => !b.Flag);
            }
        }

        public int GetSubscriberCount()
        {
            lock (_syncLocker)
            {
                return _list.Where(b => !b.Flag).Count();
            }
        }


        public void Dispose()
        {
            _isDisposed = true;
            lock (_syncLocker)
            {
                _list.Clear();
                _list = null;
            }
        }
    }
}

　　思维发散：实现多个QServer的主题与队列映射克隆、或者队列消息转发实现容灾集群或大容量集群等

MessageQueue

　　将主题与队列形成一个映射，并对主题映射进行管理

/****************************************************************************
*Copyright (c) 2018 Microsoft All Rights Reserved.
*CLR版本： 4.0.30319.42000
*机器名称：WENLI-PC
*公司名称：Microsoft
*命名空间：SAEA.QueueSocket.Model
*文件名： QueueCollection
*版本号： V1.0.0.0
*唯一标识：89a65c12-c4b3-486b-a933-ad41c3db6621
*当前的用户域：WENLI-PC
*创建人： yswenli
*电子邮箱：wenguoli_520@qq.com
*创建时间：2018/3/6 10:31:11
*描述：
*
*=====================================================================
*修改标记
*修改时间：2018/3/6 10:31:11
*修改人： yswenli
*版本号： V1.0.0.0
*描述：
*
*****************************************************************************/

using SAEA.Commom;
using SAEA.Sockets.Interface;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace SAEA.QueueSocket.Model
{
    public class MessageQueue : ISyncBase, IDisposable
    {
        bool _isDisposed = false;

        ConcurrentDictionary<string, QueueBase> _list;

        object _syncLocker = new object();

        public object SyncLocker
        {
            get
            {
                return _syncLocker;
            }
        }

        public MessageQueue()
        {
            _list = new ConcurrentDictionary<string, QueueBase>();

            ThreadHelper.Run(() =>
            {
                while (!_isDisposed)
                {
                    var list = _list.Values.Where(b => b.Expired <= DateTimeHelper.Now);
                    if (list != null)
                    {
                        foreach (var item in list)
                        {
                            if (item.Length == 0)
                            {
                                _list.TryRemove(item.Topic, out QueueBase q);
                            }
                        }
                    }
                    ThreadHelper.Sleep(10000);
                }
            }, true, System.Threading.ThreadPriority.Highest);
        }


        public void Enqueue(string topic, string data)
        {
            var queue = _list.Values.FirstOrDefault(b => b.Topic.Equals(topic));
            lock (_syncLocker)
            {
                if (queue == null)
                {
                    queue = new QueueBase(topic);
                    _list.TryAdd(topic, queue);
                }                
            }
            queue.Enqueue(data);
        }


        public string Dequeue(string topic)
        {
            var queue = _list.Values.FirstOrDefault(b => b.Topic.Equals(topic));
            if (queue != null)
            {
                return queue.Dequeue();
            }
            return null;
        }

        /// <summary>
        /// 批量读取数据
        /// </summary>
        /// <param name="topic"></param>
        /// <param name="maxSize"></param>
        /// <param name="maxTime"></param>
        /// <returns></returns>
        public List<string> DequeueForList(string topic, int maxSize = 500, int maxTime = 500)
        {
            List<string> result = new List<string>();
            bool running = true;
            var m = 0;
            var task = Task.Factory.StartNew(() =>
            {
                while (running)
                {
                    var data = Dequeue(topic);
                    if (data != null)
                    {
                        result.Add(data);
                        m++;
                        if (m == maxSize)
                        {
                            running = false;
                        }
                    }
                    else
                    {
                        ThreadHelper.Sleep(1);
                    }
                }
            });
            Task.WaitAll(new Task[] { task }, maxTime);
            running = false;
            return result;
        }

        public string BlockDequeue(string topic)
        {
            var queue = _list.Values.FirstOrDefault(b => b.Topic == topic);
            if (queue != null)
            {
                return queue.BlockDequeue();
            }
            return null;
        }

        public List<QueueBase> ToList()
        {
            lock (_syncLocker)
            {
                return _list.Values.ToList();
            }
        }

        public long GetCount(string topic)
        {
            var queue = _list.Values.FirstOrDefault(b => b.Topic == topic);
            if (queue != null)
                return queue.Length;
            return 0;
        }

        public void Dispose()
        {
            _isDisposed = true;
            _list.Clear();
                _list = null;
        }
    }
}

　　思维发散：增加硬盘持久化以实现down机容灾、增加ack确认再移除以实现高可靠性等

QCoder

　　在QServer和QClient之间进行传输编解码，这个编解码的速度直接影响消息队列的传输性能；本人使用了2种方案：1.使用类似redis传输方案，使用回车作为分隔符方式，这种方案结果要么一个字节一个字节检查分隔符，这种for操作还是C、C++屌，C#做这个真心不行；要么先将字节数组通过Encoding转换成String再来for，虽说能提升几倍性能，但是遇到不完整的字节数组时，本人没有找一个好的方法。2.使用自定义类型+长度+内容这种格式

/****************************************************************************
*Copyright (c) 2018 Microsoft All Rights Reserved.
*CLR版本： 4.0.30319.42000
*机器名称：WENLI-PC
*公司名称：Microsoft
*命名空间：SAEA.QueueSocket.Net
*文件名： QCoder
*版本号： V1.0.0.0
*唯一标识：88f5a779-8294-47bc-897b-8357a09f2fdb
*当前的用户域：WENLI-PC
*创建人： yswenli
*电子邮箱：wenguoli_520@qq.com
*创建时间：2018/3/5 18:01:56
*描述：
*
*=====================================================================
*修改标记
*修改时间：2018/3/5 18:01:56
*修改人： yswenli
*版本号： V1.0.0.0
*描述：
*
*****************************************************************************/

using SAEA.Commom;
using SAEA.QueueSocket.Model;
using SAEA.QueueSocket.Type;
using SAEA.Sockets.Interface;
using System;
using System.Collections.Generic;
using System.Text;

namespace SAEA.QueueSocket.Net
{
    public sealed class QCoder : ICoder
    {
        static readonly int MIN = 1 + 4 + 4 + 0 + 4 + 0 + 0;

        private List<byte> _buffer = new List<byte>();

        private object _locker = new object();

        public void Pack(byte[] data, Action<DateTime> onHeart, Action<ISocketProtocal> onUnPackage, Action<byte[]> onFile)
        {

        }

        /// <summary>
        /// 队列编解码器
        /// </summary>
        public QueueCoder QueueCoder { get; set; } = new QueueCoder();

        /// <summary>
        /// 包解析
        /// </summary>
        /// <param name="data"></param>
        /// <param name="OnQueueResult"></param>
        public void GetQueueResult(byte[] data, Action<QueueResult> OnQueueResult)
        {
            lock (_locker)
            {
                try
                {
                    _buffer.AddRange(data);

                    if (_buffer.Count > (1 + 4 + 4 + 0 + 4 + 0 + 0))
                    {
                        var buffer = _buffer.ToArray();

                        QCoder.Decode(buffer, (list, offset) =>
                        {
                            if (list != null)
                            {
                                foreach (var item in list)
                                {
                                    OnQueueResult?.Invoke(new QueueResult()
                                    {
                                        Type = (QueueSocketMsgType)item.Type,
                                        Name = item.Name,
                                        Topic = item.Topic,
                                        Data = item.Data
                                    });
                                }
                                _buffer.RemoveRange(0, offset);
                            }
                        });
                    }
                }
                catch (Exception ex)
                {
                    ConsoleHelper.WriteLine("QCoder.GetQueueResult error:" + ex.Message + ex.Source);
                    _buffer.Clear();
                }
            }
        }



        /// <summary>
        /// socket 传输字节编码
        /// 格式为：1+4+4+x+4+x+4
        /// </summary>
        /// <param name="queueSocketMsg"></param>
        /// <returns></returns>
        public static byte[] Encode(QueueSocketMsg queueSocketMsg)
        {
            List<byte> list = new List<byte>();

            var total = 4 + 4 + 4;

            var nlen = 0;

            var tlen = 0;

            byte[] n = null;
            byte[] tp = null;
            byte[] d = null;

            if (!string.IsNullOrEmpty(queueSocketMsg.Name))
            {
                n = Encoding.UTF8.GetBytes(queueSocketMsg.Name);
                nlen = n.Length;
                total += nlen;
            }
            if (!string.IsNullOrEmpty(queueSocketMsg.Topic))
            {
                tp = Encoding.UTF8.GetBytes(queueSocketMsg.Topic);
                tlen = tp.Length;
                total += tlen;
            }
            if (!string.IsNullOrEmpty(queueSocketMsg.Data))
            {
                d = Encoding.UTF8.GetBytes(queueSocketMsg.Data);
                total += d.Length;
            }

            list.Add(queueSocketMsg.Type);
            list.AddRange(BitConverter.GetBytes(total));
            list.AddRange(BitConverter.GetBytes(nlen));
            if (nlen > 0)
                list.AddRange(n);
            list.AddRange(BitConverter.GetBytes(tlen));
            if (tlen > 0)
                list.AddRange(tp);
            if (d != null)
                list.AddRange(d);
            var arr = list.ToArray();
            list.Clear();
            return arr;
        }

        /// <summary>
        /// socket 传输字节解码
        /// </summary>
        /// <param name="data"></param>
        /// <param name="onDecode"></param>
        public static bool Decode(byte[] data, Action<QueueSocketMsg[], int> onDecode)
        {
            int offset = 0;

            try
            {
                if (data != null && data.Length > offset + MIN)
                {
                    var list = new List<QueueSocketMsg>();

                    while (data.Length > offset + MIN)
                    {
                        var total = BitConverter.ToInt32(data, offset + 1);

                        if (data.Length >= offset + total + 1)
                        {
                            offset += 5;

                            var qm = new QueueSocketMsg((QueueSocketMsgType)data[0]);
                            qm.Total = total;

                            qm.NLen = BitConverter.ToInt32(data, offset);
                            offset += 4;


                            if (qm.NLen > 0)
                            {
                                var narr = new byte[qm.NLen];
                                Buffer.BlockCopy(data, offset, narr, 0, narr.Length);
                                qm.Name = Encoding.UTF8.GetString(narr);
                            }
                            offset += qm.NLen;

                            qm.TLen = BitConverter.ToInt32(data, offset);

                            offset += 4;

                            if (qm.TLen > 0)
                            {
                                var tarr = new byte[qm.TLen];
                                Buffer.BlockCopy(data, offset, tarr, 0, tarr.Length);
                                qm.Topic = Encoding.UTF8.GetString(tarr);
                            }
                            offset += qm.TLen;

                            var dlen = qm.Total - 4 - 4 - qm.NLen - 4 - qm.TLen;

                            if (dlen > 0)
                            {
                                var darr = new byte[dlen];
                                Buffer.BlockCopy(data, offset, darr, 0, dlen);
                                qm.Data = Encoding.UTF8.GetString(darr);
                                offset += dlen;
                            }
                            list.Add(qm);
                        }
                        else
                        {
                            break;
                        }
                    }
                    if (list.Count > 0)
                    {
                        onDecode?.Invoke(list.ToArray(), offset);
                        return true;
                    }
                }
            }
            catch (Exception ex)
            {
                ConsoleHelper.WriteLine($"QCoder.Decode error:{ex.Message} stack:{ex.StackTrace} data:{data.Length} offset:{offset}");
            }
            onDecode?.Invoke(null, 0);
            return false;
        }


        /// <summary>
        /// dispose
        /// </summary>
        public void Dispose()
        {
            _buffer.Clear();
            _buffer = null;
        }



    }
}

测试

　　简单的How to do和Why do已经完成了，是时候定义个Producer、Consumer来测试一把了

using SAEA.QueueSocket;
using SAEA.Commom;
using SAEA.QueueSocket.Model;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace SAEA.QueueSocketTest
{
    class Program
    {
        static void Main(string[] args)
        {
            do
            {
                ConsoleHelper.WriteLine("输入s启动队列服务器,输入p启动生产者，输入c启动消费者");

                var inputStr = ConsoleHelper.ReadLine();

                if (!string.IsNullOrEmpty(inputStr))
                {
                    var topic = "测试频道";

                    switch (inputStr.ToLower())
                    {
                        case "s":
                            ConsoleHelper.Title = "SAEA.QueueServer";
                            ServerInit();
                            break;
                        case "p":
                            ConsoleHelper.Title = "SAEA.QueueProducer";
                            ConsoleHelper.WriteLine("输入ip:port连接到队列服务器");
                            inputStr = ConsoleHelper.ReadLine();
                            ProducerInit(inputStr, topic);
                            break;
                        case "c":
                            ConsoleHelper.Title = "SAEA.QueueConsumer";
                            ConsoleHelper.WriteLine("输入ip:port连接到队列服务器");
                            inputStr = ConsoleHelper.ReadLine();
                            ConsumerInit(inputStr, topic);
                            break;
                        default:
                            ServerInit();
                            inputStr = "127.0.0.1:39654";
                            ProducerInit(inputStr, topic);
                            ConsumerInit(inputStr, topic);
                            break;
                    }
                    ConsoleHelper.WriteLine("回车退出！");
                    ConsoleHelper.ReadLine();
                    return;
                }
            }
            while (true);
        }



        static QServer _server;
        static void ServerInit()
        {
            _server = new QServer();
            _server.OnDisconnected += Server_OnDisconnected;
            _server.CalcInfo((ci, qi) =>
            {
                var result = string.Format("生产者：{0} 消费者：{1} 收到消息:{2} 推送消息:{3}{4}", ci.Item1, ci.Item2, ci.Item3, ci.Item4, Environment.NewLine);

                qi.ForEach((item) =>
                {
                    result += string.Format("队列名称：{0} 堆积消息数：{1} {2}", item.Item1, item.Item2, Environment.NewLine);
                });
                ConsoleHelper.WriteLine(result);
            });
            _server.Start();
        }

        private static void Server_OnDisconnected(string ID, Exception ex)
        {
            _server.Clear(ID);
            if (ex != null)
            {
                ConsoleHelper.WriteLine("{0} 已从服务器断开，err:{1}", ID, ex.ToString());
            }
        }

        static void ProducerInit(string ipPort, string topic)
        {
            int pNum = 0;

            //string msg = "主要原因是由于在高并发环境下，由于来不及同步处理，请求往往会发生堵塞，比如说，大量的insert，update之类的请求同时到达MySQL，直接导致无数的行锁表锁，甚至最后请求会堆积过多，从而触发too many connections错误。通过使用消息队列，我们可以异步处理请求，从而缓解系统的压力。";
            string msg = "123";
            if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";

            QClient producer = new QClient("productor" + Guid.NewGuid().ToString("N"), ipPort);

            producer.OnError += Producer_OnError;

            producer.OnDisconnected += Client_OnDisconnected;

            producer.ConnectAsync((s) =>
            {
                Task.Factory.StartNew(() =>
                {
                    var old = 0;
                    var speed = 0;
                    while (producer.Connected)
                    {
                        speed = pNum - old;
                        old = pNum;
                        ConsoleHelper.WriteLine("生产者已成功发送：{0} 速度：{1}/s", pNum, speed);
                        Thread.Sleep(1000);
                    }
                });

                var list = new List<Tuple<string, byte[]>>();
                

                while (producer.Connected)
                {                   

                    producer.Publish(topic, msg);

                    Interlocked.Increment(ref pNum);
                }
            });


        }

        private static void Producer_OnError(string ID, Exception ex)
        {
            ConsoleHelper.WriteLine("id:" + ID + ",error:" + ex.Message);
        }

        static void ConsumerInit(string ipPort, string topic)
        {
            if (string.IsNullOrEmpty(ipPort)) ipPort = "127.0.0.1:39654";
            QClient consumer = new QClient("subscriber-" + Guid.NewGuid().ToString("N"), ipPort);
            consumer.OnMessage += Subscriber_OnMessage;
            consumer.OnDisconnected += Client_OnDisconnected;
            consumer.ConnectAsync((s) =>
            {
                Task.Factory.StartNew(() =>
                {
                    var old = 0;
                    var speed = 0;
                    while (consumer.Connected)
                    {
                        speed = _outNum - old;
                        old = _outNum;
                        ConsoleHelper.WriteLine("消费者已成功接收：{0} 速度：{1}/s", _outNum, speed);
                        Thread.Sleep(1000);
                    }
                });

                consumer.Subscribe(topic);
            });

        }

        private static void Client_OnDisconnected(string ID, Exception ex)
        {
            ConsoleHelper.WriteLine("当前连接已关闭");
        }

        static int _outNum = 0;

        private static void Subscriber_OnMessage(QueueResult obj)
        {
            if (obj != null)
                _outNum += 1;
        }
    }
}

　　单线程的、单生产者、单消费者、单队列服务器的测试结果如下图：

　　到此一个自行实现的简单的消息队列完成了，虽说它离实际产品还很遥远，但是本人还是觉的技术的提升离不开钻研，路漫漫其修远兮，吾将上下而求索！

转载请标明本文来源：http://www.cnblogs.com/yswenli/p//9029587.html 
更多内容欢迎star作者的github：https://github.com/yswenli/SAEA
如果发现本文有什么问题和任何建议，也随时欢迎交流~