毫秒级定时任务定时执行定时任务执行软件 —— 定时执行专家

Posted 2022-01-07 boomworks

《定时执行专家》软件的一个重要的特点就是能够毫秒级定时执行任务，能够保证误差在50毫秒以内。因为毫秒级的触发要求非常快的时间检测速度，为了能达到这个要求，我们采用了多线程并行处理的方式。

多线程的并行处理主要体现在以下两个功能上：

1、触发器检查线程。检查触发器是否到了触发时间，这里按照触发器类型分成了 11个线程，并发执行；

2、另外是任务执行线程。每个任务的执行都是在新线程里面执行的，各个任务都不存在相互等待。

可以通过“触发器对话框”界面，设置以下四种“秒”级触发条件：

- 倒计时

- 伴随软件启动

- 空闲时间

- 间隔时间

【使用手册】

https://blog.csdn.net/boomworks/article/details/116405931

【下载链接】

TimingExecutor-V5.6-211218.zip

链接：百度网盘 请输入提取码

提取码：boom

// -------------------------------------------------------------------------------------

附：

一、软件简介

《定时执行专家》是一款制作精良、功能全面、使用简单的专业定时执行工具软件。支持 18 种任务类型，11 种任务触发方式（包含 Cron方式），触发精度达到“秒”级。软件无需安装，无使用时间限制，欢迎下载使用。软件使用 Unicode 编码，可以在英文、日文等所有外文 Windows 系统下正常使用，并且软件带有中、日、英多国语言界面版本，可自由切换。

这次版本升级间隔了10多年，在《PC定时执行专家 4.0》的基础上，做了重大升级和更新。重写这个软件，希望这个新版本能在各种应用场景发挥它的作用。

（图1-1，定时执行专家 - 主窗口）

二、适用人群及应用场景

- 每天工作在电脑前面的白领

- IT管理人员

- 系统维护管理人员

- 程序开发人员

- 办公室人员

- 有定时播放需求的学校、机关

- 有定时截屏监控需求的场景

三、软件功能概要

1、支持 18 种任务类型 

1） 日程提醒；2） 打开网址；3） 打开文件夹；4） 打开文件；5） 备份目录；6） 执行DOS命令；7） 执行批处理文件（.bat） ；8） 关闭显示器；9） 清空回收站；10） 锁定此电脑；11） 关机；12） 重启；13） 注销；14） 睡眠；15） 休眠；16） 发送UDP消息；17） 自动截屏（截屏并保存到指定目录）；18） 关闭程序

2、支持 11 种触发方式 

1） 倒计时；2） 随软件启动；3） 空闲时间； 4） 间隔时间；5） 具体时间；6） 每小时；7） 每天；8） 每周；9） 每月；10） 每年；11） Cron方式（Cron界面化设置方式，易于使用，可自行百度Cron表达式了解）

* [注] 前 4 种触发方式，可以指定小时、分钟、秒种，可以精确执行”秒“级的任务。

* [注] 新功能会不断更新，详情请查看作者的博客（软件关于对话框，有博客链接）

【关键字/Keyword】

boomworks PC定时执行专家 定时执行专家 定时执行工具 定时执行 定时关机 自动关机软件 自动关机 关机软件 定时任务管理 定时任务 任务管理 自动截屏 自动屏幕截图 屏幕截图 无察觉截屏 隐身执行 超级网搜 全网搜索 代码统计工具 代码统计分析工具 代码统计 代码分析

// -------------------------------------------------------------------------------------

附：

一、线程池的任务执行机制

任务调度是线程池的主要入口，当用户提交了一个任务，接下来这个任务将如何执行都是由这个阶段决定的。了解这部分就相当于了解了线程池的核心运行机制。

首先，所有任务的调度都是由execute方法完成的，这部分完成的工作是：检查现在线程池的运行状态、运行线程数、运行策略，决定接下来执行的流程，是直接申请线程执行，或是缓冲到队列中执行，亦或是直接拒绝该任务。其执行过程如下：

首先检测线程池运行状态，如果不是RUNNING，则直接拒绝，线程池要保证在RUNNING的状态下执行任务。

如果workerCount < corePoolSize，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= corePoolSize，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中。

如果workerCount >= corePoolSize && workerCount < maximumPoolSize，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务。

如果workerCount >= maximumPoolSize，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

二、软件定时器实现的思路

软件开发中，软件定时器是常用的工具。定时执行特定任务和延时功能，都可以用软件定时器实现。

　　常见的延时函数的实现做法有：

　　1. 使用空指令进行延时，通过控制空指令的执行次数，进行延时。优点：不需要占用系统外设。缺点：系统运行指定个空指令的时间不稳定，中途出现的中断处理会严重影响计时的精确性。

　　2.使用单片机的定时器外设，设定特定的时间产生中断，进行计时。优点：计时准确，不受其他中断影响计时。缺点：浪费单片机外设资源，并且延时处理不能嵌套调用，灵活性不够。

　　这里要介绍的是利用单片机内部的sysTicket 定时器实现的软件定时器。sysTicket timer每毫秒产生一次中断，单片机内有一个无符号类型的32位全局变量msTicket对中断次数进行计数，我们可以认为msTicket

为当前“系统时间”。

　　先介绍相对简单的ms定时器，ms定时器的结构定义如下：

typedef struct

    uint16_t start;
    uint32_t value;
MsSoftTimer;

　　start字段用来表示定时器的开关状态，考虑到字节对齐的问题，用了十六位的类型。如果单片机存储资源紧张，可以不用这个字段。value字段用来保存开始计时时刻系统的时间，也就是msTicket的值。

ms定时器的接口函数如下：

 1 #define        def_ms_tm(tm)    MsSoftTimer tm;
 2 #define        declare_ms_tm(tm)    extern MsSoftTimer tm;
 3 #define        get_ms_tm_val(tm)         _get_ms_tm_val(tm.value)
 4 
 5 #define  start_ms_tm(tm)     do  \\
 6                          \\
 7     tm.start = 1;         \\
 8     tm.value = get_msTicks();     \\
 9 while(0)
10 
11 #define  init_ms_tm(tm)     do  \\
12                          \\
13     tm.start = 0;         \\
14     tm.value = 0;        \\
15 while(0)
16 
17 #define  is_ms_tm_on(tm)     ( tm.start)
18 #define  stop_ms_tm(tm)     tm.start = 0

定义定时器，本质是就是定义一个定时器类型的变量。可以嵌套调用，如果要在中断处理函数中使用软件定时器，要先将msTicket 中断的优先级设置为最高级别的，并且可以抢占。获取当前的计时时间，就是将当前的“系统时间”，减去定时器开始计时时刻的时间。具体实现如下：

 1 uint32_t _get_ms_tm_val(uint32_t pre_timer_val)
 2 
 3     uint32_t curr_timer_val = msTicks;
 4     uint32_t ret_timer_val = 0;
 5     
 6     if ( curr_timer_val >= pre_timer_val)
 7     
 8         ret_timer_val  = curr_timer_val - pre_timer_val;
 9     
10     else
11     
12         ret_timer_val = 0xFFFFFFFF - pre_timer_val + curr_timer_val;
13     
14 
15     return ret_timer_val;
16 

第12行代码中，对msTicket 变量溢出做了判断和处理。

利于ms软件定时器实现的ms延时函数如下：

void delay_ms(uint32_t ms)

    if ( ms == 0) return ;
    def_ms_tm(tm_ms_count);
    start_ms_tm(tm_ms_count);
    while ( get_ms_tm_val(tm_ms_count) < ms)
    ;
    stop_ms_tm(tm_ms_count);

us 定时器实现原理跟ms定时器类似，但会稍微复杂一些。us定时利用系统sysTicket 定时器内部的计数值（SysTick Current Value）进行计时。如果系统时钟为20M,每隔1us，SysTick Current Value减少20。

如果系统时钟为48M，每隔1us，SysTick Current Value 减少48。系统sysTicket 定时器结构如下：

1 typedef struct
2 
3   __IO uint32_t CTRL;                    /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
4   __IO uint32_t LOAD;                    /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register       */
5   __IO uint32_t VAL;                     /*!< Offset: 0x008 (R/W)  SysTick Current Value Register      */
6   __I  uint32_t CALIB;                   /*!< Offset: 0x00C (R/ )  SysTick Calibration Register        */
7  SysTick_Type;

us 定时器的结构体如下：

1 typedef struct 
2 
3     uint16_t start;
4     uint32_t init_ticket_val;
5     uint32_t init_ms_val;
6 UsSoftTimer;

init_ticket_val 记录的是开始计时时刻SysTick Current Value的值。init_ms_val 记录的是开始计时时刻msTicket 的值。

us 定时器接口函数实现如下：

 1 void _start_us_sw(USSoftTimer* pTM)
 2 
 3     pTM->init_ms_val =  msTicks;
 4     pTM->init_ticket_val = SysTick->VAL;
 5     pTM->start = 1;
 6 
 7 
 8 #pragma O0
 9 uint32_t _get_us_tm_val(USSoftTimer* pTM)
10 
11     volatile uint32_t curr_ms = msTicks;    
12     volatile uint32_t curr_ticket_val = SysTick->VAL;
13     volatile uint32_t ms_interval = 0;
14     volatile uint32_t sys_clock = SysTick -> LOAD / 1000;
15     volatile uint32_t us_interval = 0;
16     
17     
18     if ( curr_ticket_val > pTM->init_ticket_val)
19     us_interval = ( SysTick->LOAD  - (curr_ticket_val - pTM->init_ticket_val)) / sys_clock;
20     else
21     us_interval = (pTM->init_ticket_val - curr_ticket_val) / sys_clock;
22     
23     if ( curr_ms != pTM->init_ms_val)
24     
25 
26     if ( curr_ms >= pTM->init_ms_val)
27         ms_interval = curr_ms - pTM->init_ms_val;
28     else
29         ms_interval = 0xFFFFFFFF - pTM->init_ms_val+ curr_ms;
30     
31     if ( curr_ticket_val > pTM->init_ticket_val)
32         ms_interval -= 1;
33 
34     us_interval += ms_interval * 1000;
35 
36     
37 
38     return us_interval;
39 
40 
41 #define       def_us_tm(tm)       UsSoftTimer tm 
42 #define       declare_us_tm(tm)   extern    UsSoftTimer tm        
43 #define       get_us_tm_val(tm)    _get_us_tm_val(&tm)
44 #define is_us_tm_on(tm)    (1== tm.start)
45 #define stop_us_tm(tm)    tm.start = 0
46 #define start_us_tm(tm)    _start_us_sw(&tm)

us延时函数的实现如下：

1 void delay_us(uint32_t us)
2 
3     if ( us <= 1) return ;
4     def_us_tm(tm_us_count);
5     start_us_tm(tm_us_count);
6     while ( get_us_tm_val(tm_us_count) < us)
7     ;
8     stop_us_tm(tm_us_count);
9 

// END