如何实现定时推送的具体方案

 public interface IRingQueue { /// 
 /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles] /// 
 /// The specified task is executed after N seconds. /// Definitions of callback void Add(long delayTime,Action action); /// 
 /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles] /// 
 /// The specified task is executed after N seconds. /// Definitions of callback. /// Parameters used in the callback function. void Add(long delayTime, Action action, T data); /// 
 /// Add tasks [add tasks will automatically generate: task Id, task slot location, number of task cycles] /// 
 ///  /// Definitions of callback /// Parameters used in the callback function. /// Task ID, used when deleting tasks. void Add(long delayTime, Action action, T data, long id); /// 
 /// Remove tasks [need to know: where the task is, which specific task]. /// 
 /// Task slot location /// Task ID, used when deleting tasks. void Remove(long id); /// 
 /// Launch queue. /// 
 void Start(); } public interface ITask { }

 using System; using System.Collections.Concurrent; using System.Linq; using System.Threading; using System.Threading.Tasks; using DelayMessageApp.Interfaces; namespace DelayMessageApp.Achieves.Base { public abstract class BaseQueue : IRingQueue { private long _pointer = 0L; private ConcurrentBag>[] _arraySlot; private int ArrayMax; /// 
 /// Ring queue. /// 
 public ConcurrentBag>[] ArraySlot { get { return _arraySlot ?? (_arraySlot = new ConcurrentBag>[ArrayMax]); } } public BaseQueue(int arrayMax) { if (arrayMax <60 && arraymax % 60 0) throw new exception("ring queue length cannot be less than and is a multiple of ."); arraymax; } public void add(long delaytime, action action) { Add(delayTime, action, default(T)); } public void Add(long delayTime,Action action,T data) { Add(delayTime, action, data,0); } public void Add(long delayTime, Action action, T data,long id) { NextSlot(delayTime, out long cycle, out long pointer); ArraySlot[pointer] =  ArraySlot[pointer] ?? (ArraySlot[pointer] = new ConcurrentBag>()); var baseTask = new BaseTask(cycle, action, data,id); ArraySlot[pointer].Add(baseTask); } /// 
 /// Remove tasks based on ID. /// 
 ///  public void Remove(long id) { try { Parallel.ForEach(ArraySlot, (ConcurrentBag> 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()); } } /// 
 /// Calculate the information of the next slot. /// 
 /// Delayed execution time. /// Number of turns. /// Task location. 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) { 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; } } /// 
 /// Get the current location of the pointer. /// 
 ///  private long GetPointer() { return Interlocked.Read(ref _pointer); } /// 
 /// Reset pointer position. /// 
 private void ReSetPointer() { Interlocked.Exchange(ref _pointer, 0); } /// 
 /// Pointer moves clockwise. /// 
 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 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; } } } } using System; using System.Threading; using DelayMessageApp.Interfaces; namespace DelayMessageApp.Achieves.Base { public class BaseTask : ITask { private long _cycle; private long _id; private T _data; public Action 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 action, T data,long id) { Cycle = cycle; TaskAction = action; Data = data; Id = id; } public BaseTask(long cycle, Action action,T data) { Cycle = cycle; TaskAction = action; Data = data; } public BaseTask(long cycle, Action action) { Cycle = cycle; TaskAction = action; } public void SubCycleNumber() { Interlocked.Decrement(ref _cycle); } } }

 public static void Start() { //1.Initialize queues of different granularity. IRingQueue minuteRingQueue = new MinuteQueue(); //2.Open thread. var lstTasks = new List { Task.Factory.StartNew(minuteRingQueue.Start) }; //3.Add tasks performed in different periods. minuteRingQueue.Add(5, new Action((NewsModel newsObj) => { Console.WriteLine(newsObj.News); }), new NewsModel() { News = "Trump's visit to China！" }); minuteRingQueue.Add(10, new Action((NewsModel newsObj) => { Console.WriteLine(newsObj.News); }), new NewsModel() { News = "Putin Pu's visit to China！" }); minuteRingQueue.Add(60, new Action((NewsModel newsObj) => { Console.WriteLine(newsObj.News); }), new NewsModel() { News = "Eisenhower's visit to China！" }); minuteRingQueue.Add(120, new Action((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(); }