C# 线程系列三 定时器线程

上一篇文章我们讲诉了自定义线程执行器和任务处理器

我们继续来讲解自定义线程的定时执行器，我们在很多场景下需要做到某些状态或者数据进行更新，如果事情很多很杂，很时候时候会创建很多不同的定时器那么势必会照成系统的消耗和性能低下的问题！今天我们来解决这一问题。

首先我们创建定时任务执行器基类

 /// <summary>
     ///
     /// </summary>
     public abstract class TimerTaskBase : BaseTask
     {

         /// <summary>
         /// 开始执行的时间
         /// </summary>
         public long StartTime { get; set; }

         /// <summary>
         /// 是否一开始执行一次
         /// </summary>
         public bool IsStartAction { get; set; }

         /// <summary>
         /// 结束时间
         /// </summary>
         public long EndTime { get; set; }

         /// <summary>
         /// 执行次数
         /// </summary>
         public int ActionCount { get; set; }

         /// <summary>
         /// 已经执行的次数
         /// </summary>
         public int AActionCount { get; set; }

         /// <summary>
         /// 间隔执行时间
         /// </summary>
         public int IntervalTime { get; set; }

         /// <summary>
         /// 制定执行次数的定时任务
         /// </summary>
         /// <param name="startTime">0表示立即执行,否则延迟执行,填写开始时间</param>
         /// <param name="intervalTime">执行间隔时间,小于10毫秒,当10毫秒处理</param>
         /// <param name="isStartAction">是否一开始执行一次</param>
         /// <param name="actionCount">需要执行的次数</param>
         public TimerTaskBase(long startTime, int intervalTime, bool isStartAction, int actionCount)
         {
             this.StartTime = startTime;
             this.IntervalTime = intervalTime;
             this.IsStartAction = isStartAction;
             this.ActionCount = actionCount;
             ;
         }

         /// <summary>
         /// 制定结束时间的定时任务
         /// </summary>
         /// <param name="startTime">0表示立即执行,否则延迟执行,填写开始时间</param>
         /// <param name="intervalTime">执行间隔时间,小于10毫秒,当10毫秒处理</param>
         /// <param name="endTime">执行结束时间</param>
         /// <param name="isStartAction">是否一开始执行一次</param>
         public TimerTaskBase(long startTime, int intervalTime, long endTime, bool isStartAction)
         {
             this.StartTime = startTime;
             this.IntervalTime = intervalTime;
             this.IsStartAction = isStartAction;
             ;
             this.EndTime = endTime;
         }

         /// <summary>
         /// 制定开始时间,无限执行任务
         /// </summary>
         /// <param name="startTime">0表示立即执行,否则延迟执行,填写开始时间</param>
         /// <param name="intervalTime">执行间隔时间,小于10毫秒,当 10 毫秒处理 建议 10 毫秒的倍数</param>
         /// <param name="isStartAction">是否一开始执行一次</param>
         public TimerTaskBase(long startTime, int intervalTime, bool isStartAction)
         {
             this.StartTime = startTime;
             this.IntervalTime = intervalTime;
             this.IsStartAction = isStartAction;
             ;
             ;
         }

         public TimerTaskBase()
         {
             // TODO: Complete member initialization
         }
     }

上面的代码实现了，开始时间，间隔时间，结束时间和执行次数 的控制

那么我们来看看定时器线程的设计

 public class TimerThread
     {
         public TimerThread()
         {
             System.Threading.Thread thread = new System.Threading.Thread(new System.Threading.ThreadStart(Run));
             thread.IsBackground = true;
             thread.Start();
         }

         /// <summary>
         /// 任务队列
         /// </summary>
         private List<TimerTaskBase> taskQueue = new List<TimerTaskBase>();

         /// <summary>
         /// 加入任务
         /// </summary>
         /// <param name="t"></param>
         public void AddTask(TimerTaskBase t)
         {
             if (t.IsStartAction)
             {
                 //满足添加队列前先执行一次
                 t.Run();
             }
             lock (taskQueue)
             {
                 taskQueue.Add(t);
             }
         }

         public long GetDate()
         {
             return Convert.ToInt64(System.DateTime.Now.ToString("yyyyMMddHHmmssfff"));
         }

         //这里的线程同步器，不是用来通知的，
         //只是用来暂停的，因为Thread.Sleep() 消耗开销比较大
         ManualResetEvent mre = new ManualResetEvent(false);

         /// <summary>
         /// 重构函数执行器
         /// </summary>
         private void Run()
         {
             ///无限循环执行函数器
             while (true)
             {
                 )
                 {
                     IEnumerable<TimerTaskBase> collections = null;
                     lock (taskQueue)
                     {
                         //拷贝一次队列 预防本次轮训检查的时候有新的任务添加
                         //否则循环会出错 集合被修改无法迭代
                         collections = new List<TimerTaskBase>(taskQueue);
                     }
                     //开始迭代
                     foreach (TimerTaskBase tet in collections)
                     {
                         int actionCount = tet.AActionCount;
                         long timers = GetDate();
                          && timers > tet.EndTime) || (tet.ActionCount >  && actionCount >= tet.ActionCount))
                         {
                             //任务过期
                             lock (taskQueue)
                             {
                                 taskQueue.Remove(tet);
                             }
                             continue;
                         }
                         //获取最后一次的执行时间
                         long lastactiontime = tet.TempAttribute.getlongValue("lastactiontime");
                          && Math.Abs(timers - lastactiontime) < tet.IntervalTime)
                         {
                             continue;
                         }
                         //记录出来次数
                         tet.AActionCount++;
                         //记录最后执行的时间
                         tet.TempAttribute.setValue("lastactiontime", timers);

                         //上面的代码执行情况是非常几乎不用考虑消耗问题

                         //下面是任务的执行需要考虑消耗，

                         //这里我们不考虑执行耗时问题，
                         //我们我这里没有涉及到后台线程池
                         //也没有具体的业务逻辑，所以都放到这里统一执行
                         tet.Run();
                     }
                 }
                 //暂停10毫秒后再次检查
                 mre.WaitOne();
             }
         }
     }

定时器为什么没有使用上一篇文章讲诉的自定义线程呢，是因为，上一篇文章的自定义线程是基于队列处理的，先进先出执行，而我们的定时器任务并非是基于队列的。所以需要单独定义。

那么我们先来实现一个每一秒执行的任务，

  /// <summary>
     /// 每秒执行的任务
     /// </summary>
     public class SecondsTimerTask : TimerTaskBase
     {
         /// <summary>
         /// 定义一秒执行一次的
         /// </summary>
         public SecondsTimerTask()
             : , , false)
         {

         }

         public override void Run()
         {
             Console.WriteLine(DateTime.Now.ToString("HH:mm:ss:ffff: ") + "我是 每秒 执行的任务");
         }
     }

我们来测试一下看看效果

     class Program
     {
         static void Main(string[] args)
         {
             TimerThread timerThread = new TimerThread();
             timerThread.AddTask(new SecondsTimerTask());
             Console.ReadLine();
         }
     }

还算是我们的预想的效果吧，每秒执行一次

接下来我们创建每分钟执行一次

     public class MinuteTimerTask : TimerTaskBase
     {
         /// <summary>
         /// 定义一分钟执行一次的
         /// </summary>
         public MinuteTimerTask()
             : ,  * , false)
         {

         }

         public override void Run()
         {
             Console.WriteLine(DateTime.Now.ToString("HH:mm:ss:ffff: ") + "我是 每分钟 执行的任务");
         }
     }

按照执行次数的定时器

     /// <summary>
     /// 我是按照执行次数结束的
     /// </summary>
     public class CountTimerTask : TimerTaskBase
     {
         /// <summary>
         /// 定义一秒执行一次的
         /// </summary>
         public CountTimerTask()
             : , , )
         {

         }

         public override void Run()
         {
             Console.WriteLine(DateTime.Now.ToString("HH:mm:ss:ffff: ") + "我是 次数 执行的任务 我要执行：" + this.ActionCount + " 次 执行了: " + this.AActionCount + " 次");
         }
     }

测试一下

    class Program
     {
         static void Main(string[] args)
         {
             TimerThread timerThread = new TimerThread();
             timerThread.AddTask(new SecondsTimerTask());

             timerThread.AddTask(new MinuteTimerTask());
             timerThread.AddTask(new CountTimerTask());

             Console.ReadLine();
         }
     }

运行结果：

到此我们的定时器线程执行器已经完成，满足我们需要做到定时更新状态，合作检查数据等应用场景！

不知道对你有没有帮助呢？

请不了吝啬你的小手，给予一个评论吧，帮助到你了请给与鼓励，如果有不足之处还请多多指教！