.NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件 (Timer 优化版) ...

在上个月写过一篇 .NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件 的文章，当时 CronSchedule 的实现是使用了，每个服务都独立进入到一个 while 循环中，进行定期扫描是否到了执行时间来实现的，但是那个逻辑有些问题，经过各位朋友的测试，发现当多个任务的时候存在一定概率不按照计划执行的情况。

感谢各位朋友的积极探讨，多交流一起进步。之前那个 while 循环的逻辑每循环一次 Task.Delay 1000 毫秒，无限循环，多个任务的时候还会同时有多个循环任务，确实不够好。
所以决定重构 CronSchedule 的实现，采用全局使用一个 Timer 的形式，每隔 1秒钟扫描一次任务队列看看是否有需要执行的任务，整体的实现思路还是之前的，如果没有看过之前那篇文章的建议先看一下，本片主要针对调整部分进行说明  .NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件 ，主要调整了 CronSchedule.cs

1. using Common;
2. using System.Reflection;
4. namespace TaskService.Libraries
5. {
6.     public class CronSchedule
7.     {
8.         private static List<ScheduleInfo> scheduleList = new();
9.         private static Timer mainTimer;
11.         public static void Builder(object context)
12.         {
13.             var taskList = context.GetType().GetMethods().Where(t => t.GetCustomAttributes(typeof(CronScheduleAttribute), false).Length > 0).ToList();
15.             foreach (var action in taskList)
16.             {
17.                 string cron = action.CustomAttributes.Where(t => t.AttributeType == typeof(CronScheduleAttribute)).FirstOrDefault()!.NamedArguments.Where(t => t.MemberName == "Cron" && t.TypedValue.Value != null).Select(t => t.TypedValue.Value!.ToString()).FirstOrDefault()!;
19.                 scheduleList.Add(new ScheduleInfo
20.                 {
21.                     CronExpression = cron,
22.                     Action = action,
23.                     Context = context
24.                 });
25.             }
27.             if (mainTimer == default)
28.             {
29.                 mainTimer = new(Run, null, 0, 1000);
30.             }
31.         }
34.         private static void Run(object? state)
35.         {
36.             var nowTime = DateTime.Parse(DateTimeOffset.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"));
38.             foreach (var item in scheduleList)
39.             {
40.                 if (item.LastTime != null)
41.                 {
42.                     var nextTime = DateTime.Parse(CronHelper.GetNextOccurrence(item.CronExpression, item.LastTime.Value).ToString("yyyy-MM-dd HH:mm:ss"));
44.                     if (nextTime == nowTime)
45.                     {
46.                         item.LastTime = DateTimeOffset.Now;
48.                         _ = Task.Run(() =>
49.                         {
50.                             item.Action.Invoke(item.Context, null);
51.                         });
52.                     }
53.                 }
54.                 else
55.                 {
56.                     item.LastTime = DateTimeOffset.Now.AddSeconds(5);
57.                 }
58.             }
59.         }
62.         private class ScheduleInfo
63.         {
64.             public string CronExpression { get; set; }
66.             public MethodInfo Action { get; set; }
68.             public object Context { get; set; }
70.             public DateTimeOffset? LastTime { get; set; }
71.         }
72.     }
74.     [AttributeUsage(AttributeTargets.Method)]
75.     public class CronScheduleAttribute : Attribute
76.     {
77.         public string Cron { get; set; }
78.     }
80. }

复制代码

这里的逻辑改为了注入任务时将 mainTimer 实例化启动，每一秒钟执行1次 Run方法，Run 方法内部用于 循环检测 scheduleList 中的任务，如果时间符合，则启动一个 Task 去执行对应的 Action，这样全局不管注册多少个服务，也只有一个 Timer 在循环运行，相对之前的 CronSchedule 实现相对更好一点。
使用的时候方法基本没怎么改，只是调整了CronSchedule.Builder 的调用 代码如下：

1. using DistributedLock;
2. using Repository.Database;
3. using TaskService.Libraries;
5. namespace TaskService.Tasks
6. {
7.     public class DemoTask : BackgroundService
8.     {
10.         private readonly IServiceProvider serviceProvider;
11.         private readonly ILogger logger;
15.         public DemoTask(IServiceProvider serviceProvider, ILogger<DemoTask> logger)
16.         {
17.             this.serviceProvider = serviceProvider;
18.             this.logger = logger;
19.         }
22.         protected override async Task ExecuteAsync(CancellationToken stoppingToken)
23.         {
24.             CronSchedule.Builder(this);
26.             await Task.Delay(-1, stoppingToken);
27.         }
31.         [CronSchedule(Cron = "0/1 * * * * ?")]
32.         public void ClearLog()
33.         {
34.             try
35.             {
36.                 using var scope = serviceProvider.CreateScope();
37.                 var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
39.                 //省略业务代码
40.                 Console.WriteLine("ClearLog:" + DateTime.Now);
41.             }
42.             catch (Exception ex)
43.             {
44.                 logger.LogError(ex, "DemoTask.ClearLog");
45.             }
46.         }
50.         [CronSchedule(Cron = "0/5 * * * * ?")]
51.         public void ClearCache()
52.         {
53.             try
54.             {
55.                 using var scope = serviceProvider.CreateScope();
56.                 var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
57.                 var distLock = scope.ServiceProvider.GetRequiredService<IDistributedLock>();
59.                 //省略业务代码
60.                 Console.WriteLine("ClearCache:" + DateTime.Now);
61.             }
62.             catch (Exception ex)
63.             {
64.                 logger.LogError(ex, "DemoTask.ClearCache");
65.             }
66.         }
68.     }
69. }

复制代码

然后启动我们的项目就可以看到如下的运行效果：

最上面连着两个 16:25:53 并不是重复调用了，只是因为这个任务配置的是 1秒钟执行1次，第一次启动任务的时候执行的较为耗时，导致第一次执行和第二次执行进入到方法中的时间差太短了，这个只在第一次产生，对后续的执行计划没有影响。
至此 .NET 纯原生实现 Cron 定时任务执行，未依赖第三方组件 (Timer 优化版) 就讲解完了，有任何不明白的，可以在文章下面评论或者私信我，欢迎大家积极的讨论交流，有兴趣的朋友可以关注我目前在维护的一个 .NET 基础框架项目，项目地址如下https://github.com/berkerdong/NetEngine.githttps://gitee.com/berkerdong/NetEngine.git
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！