实现延迟消息队列

• 交流
  
  个人博客交流群：580749909 ， 顺便推广一下自己和伙伴一起建立wpf交流群：130108655。
  
  
• 简要

 因为在偶然的一次机会下，公司让我着手开发一个数据分发端基于socket通讯的一个中间件。主要用来解决向客户端分发数据的问题，后来多了一个需求就是未付费的用户拿到的数据是有延迟的。

而付费用户则是正常的。这个时候在网上搜了很久没有找到合适的解决方案，其实能解决这个问题的方案有很多比如说用到一些大厂贡献的xxMQ中间件之类的，确实能解决问题。但是目前项目比较小

根本用不上这么重的框架，然后又搜索了半天没有暂时没有发现有人用c#来实现，所以才动手写了这个方案。

附上github源码地址

• 思路

这个方案是借鉴了另一位博主的开发思路，受到这位博主的启发然后根据自己的理解写了这个方案。附上该博主的链接地址：  1分钟实现“延迟消息”功能

在此我就不多赘述里面的内容了。

• 代码

首先写一个方案要理清楚自己的项目结构，我做了如下分层。

• Interfaces ， 这层里主要约束延迟消息队列的队列和消息任务行。

  public interface IRingQueue<T>
    {
        /// <summary>
        /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles]
        /// </summary>
        /// <param name="delayTime">The specified task is executed after N seconds.</param>
        /// <param name="action">Definitions of callback</param>
        void Add(long delayTime,Action<T> action);

        /// <summary>
        /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles]
        /// </summary>
        /// <param name="delayTime">The specified task is executed after N seconds.</param>
        /// <param name="action">Definitions of callback.</param>
        /// <param name="data">Parameters used in the callback function.</param>
        void Add(long delayTime, Action<T> action, T data);

        /// <summary>
        /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles]
        /// </summary>
        /// <param name="delayTime"></param>
        /// <param name="action">Definitions of callback</param>
        /// <param name="data">Parameters used in the callback function.</param>
        /// <param name="id">Task ID, used when deleting tasks.</param>
        void Add(long delayTime, Action<T> action, T data, long id);

        /// <summary>
        /// Remove tasks [need to know: where the task is, which specific task].
        /// </summary>
        /// <param name="index">Task slot location</param>
        /// <param name="id">Task ID, used when deleting tasks.</param>
        void Remove(long id);

        /// <summary>
        /// Launch queue.
        /// </summary>
        void Start();
    }

public interface ITask
    {
    }

• Achieves，这层里实现之前定义的接口，这里写成抽象类是为了后面方便扩展。

   public abstract class BaseQueue<T> : IRingQueue<T>
    {
        private long _pointer = 0L;
        private ConcurrentBag<BaseTask<T>>[] _arraySlot;
        private int ArrayMax;

        /// <summary>
        /// Ring queue.
        /// </summary>
        public ConcurrentBag<BaseTask<T>>[] ArraySlot
        {
            get { return _arraySlot ?? (_arraySlot = new ConcurrentBag<BaseTask<T>>[ArrayMax]); }
        }
        
        public BaseQueue(int arrayMax)
        {
            if (arrayMax < 60 && arrayMax % 60 == 0)
                throw new Exception("Ring queue length cannot be less than 60 and is a multiple of 60 .");

            ArrayMax = arrayMax;
        }

        public void Add(long delayTime, Action<T> action)
        {
            Add(delayTime, action, default(T));
        }

        public void Add(long delayTime,Action<T> action,T data)
        {
            Add(delayTime, action, data,0);
        }

        public void Add(long delayTime, Action<T> action, T data,long id)
        {
            NextSlot(delayTime, out long cycle, out long pointer);
            ArraySlot[pointer] =  ArraySlot[pointer] ?? (ArraySlot[pointer] = new ConcurrentBag<BaseTask<T>>());
            var baseTask = new BaseTask<T>(cycle, action, data,id);
            ArraySlot[pointer].Add(baseTask);
        }

        /// <summary>
        /// Remove tasks based on ID.
        /// </summary>
        /// <param name="id"></param>
        public void Remove(long id)
        {
            try
            {
                Parallel.ForEach(ArraySlot, (ConcurrentBag<BaseTask<T>> collection, ParallelLoopState state) =>
                {
                    var resulTask = collection.FirstOrDefault(p => p.Id == id);
                    if (resulTask != null)
                    {
                        collection.TryTake(out resulTask);
                        state.Break();
                    }
                });
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
        }
        
        public void Start()
        {
            while (true)
            {
                RightMovePointer();
                Thread.Sleep(1000);
                Console.WriteLine(DateTime.Now.ToString());
            }
        }

        /// <summary>
        /// Calculate the information of the next slot.
        /// </summary>
        /// <param name="delayTime">Delayed execution time.</param>
        /// <param name="cycle">Number of turns.</param>
        /// <param name="index">Task location.</param>
        private void NextSlot(long delayTime, out long cycle,out long index)
        {
            try
            {
                var circle = delayTime / ArrayMax;
                var second = delayTime % ArrayMax;
                var current_pointer = GetPointer();
                var queue_index = 0L;

                if (delayTime - ArrayMax > ArrayMax)
                {
                    circle = 1;
                }
                else if (second > ArrayMax)
                {
                    circle += 1;
                }

                if (delayTime - circle * ArrayMax < ArrayMax)
                {
                    second = delayTime - circle * ArrayMax;
                }

                if (current_pointer + delayTime >= ArrayMax)
                {
                    cycle = (int)((current_pointer + delayTime) / ArrayMax);
                    if (current_pointer + second - ArrayMax < 0)
                    {
                        queue_index = current_pointer + second;
                    }
                    else if (current_pointer + second - ArrayMax > 0)
                    {
                        queue_index = current_pointer + second - ArrayMax;
                    }
                }
                else
                {
                    cycle = 0;
                    queue_index = current_pointer + second;
                }
                index = queue_index;
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        /// <summary>
        /// Get the current location of the pointer.
        /// </summary>
        /// <returns></returns>
        private long GetPointer()
        {
            return Interlocked.Read(ref _pointer);
        }

        /// <summary>
        /// Reset pointer position.
        /// </summary>
        private void ReSetPointer()
        {
            Interlocked.Exchange(ref _pointer, 0);
        }

        /// <summary>
        /// Pointer moves clockwise.
        /// </summary>
        private void RightMovePointer()
        {
            try
            {
                if (GetPointer() >= ArrayMax - 1)
                {
                    ReSetPointer();
                }
                else
                {
                    Interlocked.Increment(ref _pointer);
                }

                var pointer = GetPointer();
                var taskCollection = ArraySlot[pointer];
                if (taskCollection == null || taskCollection.Count == 0) return;

                Parallel.ForEach(taskCollection, (BaseTask<T> task) =>
                {
                    if (task.Cycle > 0)
                    {
                        task.SubCycleNumber();
                    }

                    if (task.Cycle <= 0)
                    {
                        taskCollection.TryTake(out task);
                        task.TaskAction(task.Data);
                    }
                });
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
    }

  public class BaseTask<T> : ITask
    {
        private long _cycle;
        private long _id;
        private T _data;

        public Action<T> TaskAction { get; set; }

        public long Cycle
        {
            get { return Interlocked.Read(ref _cycle); }
            set { Interlocked.Exchange(ref _cycle, value); }
        }

        public long Id
        {
            get { return _id; }
            set { _id = value; }
        }

        public T Data
        {
            get { return _data; }
            set { _data = value; }
        }

        public BaseTask(long cycle, Action<T> action, T data,long id)
        {
            Cycle = cycle;
            TaskAction = action;
            Data = data;
            Id = id;
        }

        public BaseTask(long cycle, Action<T> action,T data)
        {
            Cycle = cycle;
            TaskAction = action;
            Data = data;
        }

        public BaseTask(long cycle, Action<T> action)
        {
            Cycle = cycle;
            TaskAction = action;
        }
        
        public void SubCycleNumber()
        {
            Interlocked.Decrement(ref _cycle);
        }
    }

• Logic，这层主要实现调用逻辑，调用者最终只需要关心把任务放进队列并指定什么时候执行就行了，根本不需要关心其它的任何信息。

 public static void Start()
        {
            //1.Initialize queues of different granularity.
            IRingQueue<NewsModel> minuteRingQueue = new MinuteQueue<NewsModel>();

            //2.Open thread.
            var lstTasks = new List<Task>
            {
                Task.Factory.StartNew(minuteRingQueue.Start)
            };

            //3.Add tasks performed in different periods.
            minuteRingQueue.Add(5, new Action<NewsModel>((NewsModel newsObj) =>
            {
                Console.WriteLine(newsObj.News);
            }), new NewsModel() { News = "Trump's visit to China！" });

            minuteRingQueue.Add(10, new Action<NewsModel>((NewsModel newsObj) =>
            {
                Console.WriteLine(newsObj.News);
            }), new NewsModel() { News = "Putin Pu's visit to China！" });

            minuteRingQueue.Add(60, new Action<NewsModel>((NewsModel newsObj) =>
            {
                Console.WriteLine(newsObj.News);
            }), new NewsModel() { News = "Eisenhower's visit to China！" });

            minuteRingQueue.Add(120, new Action<NewsModel>((NewsModel newsObj) =>
            {
                Console.WriteLine(newsObj.News);
            }), new NewsModel() { News = "Xi Jinping's visit to the US！" });

            //3.Waiting for all tasks to complete is usually not completed. Because there is an infinite loop.
            //F5 Run the program and see the effect.
            Task.WaitAll(lstTasks.ToArray());
            Console.Read();
        }

• Models，这层就是用来在延迟任务中带入的数据模型类而已了。自己用的时候换成任意自定义类型都可以。

• 截图