像各位大佬 求一个逻辑

huang337588

逻辑是这样的
我需要完成 20个任务，每个任务都是独立的
当我点击按钮1  这20个任务 依次去做，做了以后，有刷新时间，每个刷新的时间都不一，

在我完成这20个任务后，利用时钟判断 其中某个任务刷新时间已经到了，再去完成，
例如：依次做任务
1.任务后，刷新时间 = 1600秒
2.任务后，刷新时间 = 600秒
3.任务后，刷新时间 = 1200秒
4.任务后，刷新时间 = 1300秒
.....
17.任务后，刷新时间 = 1700秒
18.任务后，刷新时间 = 900秒
19.任务后，刷新时间 = 1400秒
20.任务后，刷新时间 = 1500秒

当然 600秒是最快结束的，结束以后，
在去做个 2号任务，2号结束后，根据时间18号任务又结束了，接着做18号任务.

求个思路，是用程序集或其他思路 把 1 2 3 4 .... 19.20 号任务 每个都做成处理事件，还是别的思路，这里面每个任务做法也都不一样

tj5523

  

窗口程序集名	保 留	保 留	备 注
程序集1
变量名	类 型	数组	备 注
执行任务名称	文本型
当前执行任务id	整数型
任务json	zyJsonValue

子程序名	返回值类型	公开	备 注
_启动子程序	整数型

任务json.创建 (, , , , )
任务json.置文本 (“[0].name”, “任务0”)
任务json.置整数 (“[0].delay”, 26)
任务json.置文本 (“[1].name”, “任务1”)
任务json.置整数 (“[1].delay”, 18)
任务json.置文本 (“[2].name”, “任务2”)
任务json.置整数 (“[2].delay”, 6)
任务json.置文本 (“[3].name”, “任务3”)
任务json.置整数 (“[3].delay”, 13)
判断循环首 (真)
任务判断 ()
执行任务 ()
延时 (1000)
判断循环尾 ()
返回 (0)

子程序名	返回值类型	公开	备 注
任务判断

变量名	类 型	静态	数组	备 注
i	整数型
最小时间	长整数型
当前时间	长整数型

执行任务名称 ＝ “任务0”
最小时间 ＝ 到整数 (时间_取现行时间戳 (真))
计次循环首 (任务json.取成员数 (), i)
当前时间 ＝ 任务json.取整数 (“[” ＋ 到文本 (i － 1) ＋ “].startTime”)
如果真 (最小时间 ＞ 当前时间)
最小时间 ＝ 当前时间
执行任务名称 ＝ 任务json.取文本 (“[” ＋ 到文本 (i － 1) ＋ “].name”)
当前执行任务id ＝ i － 1

计次循环尾 ()
' 判断任务是否开始   -1为未开始
如果真 (最小时间 ≥ 到整数 (时间_取现行时间戳 (真)))
当前执行任务id ＝ -1

子程序名	返回值类型	公开	备 注
执行任务

如果真 (当前执行任务id ≠ -1)  ' 判断有无任务
' 执行任务
调试输出 (执行任务名称)
' 当前任务完成
任务json.置整数 (“[” ＋ 到文本 (当前执行任务id) ＋ “]startTime”, 任务json.取整数 (“[” ＋ 到文本 (当前执行任务id) ＋ “].delay”) ＋ 到整数 (时间_取现行时间戳 (真)))

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 程序集1<br /> .程序集变量 执行任务名称, 文本型<br /> .程序集变量 当前执行任务id, 整数型<br /> .程序集变量 任务json, zyJsonValue<br /> <br /> .子程序 _启动子程序, 整数型<br /> <br /> 任务json.创建 (, , , , )<br /> 任务json.置文本 (“[0].name”, “任务0”)<br /> 任务json.置整数 (“[0].delay”, 26)<br /> 任务json.置文本 (“[1].name”, “任务1”)<br /> 任务json.置整数 (“[1].delay”, 18)<br /> 任务json.置文本 (“[2].name”, “任务2”)<br /> 任务json.置整数 (“[2].delay”, 6)<br /> 任务json.置文本 (“[3].name”, “任务3”)<br /> 任务json.置整数 (“[3].delay”, 13)<br /> .判断循环首 (真)<br />     任务判断 ()<br />     执行任务 ()<br />     延时 (1000)<br /> .判断循环尾 ()<br /> 返回 (0)<br /> <br /> .子程序 任务判断<br /> .局部变量 i, 整数型<br /> .局部变量 最小时间, 长整数型<br /> .局部变量 当前时间, 长整数型<br /> <br /> 执行任务名称 ＝ “任务0”<br /> 最小时间 ＝ 到整数 (时间_取现行时间戳 (真))<br /> .计次循环首 (任务json.取成员数 (), i)<br />     当前时间 ＝ 任务json.取整数 (“[” ＋ 到文本 (i － 1) ＋ “].startTime”)<br />     .如果真 (最小时间 ＞ 当前时间)<br />         最小时间 ＝ 当前时间<br />         执行任务名称 ＝ 任务json.取文本 (“[” ＋ 到文本 (i － 1) ＋ “].name”)<br />         当前执行任务id ＝ i － 1<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> <br /> ' 判断任务是否开始   -1为未开始<br /> .如果真 (最小时间 ≥ 到整数 (时间_取现行时间戳 (真)))<br />     当前执行任务id ＝ -1<br /> .如果真结束<br /> <br /> <br /> .子程序 执行任务<br /> <br /> .如果真 (当前执行任务id ≠ -1)  ' 判断有无任务<br />     ' 执行任务<br />     调试输出 (执行任务名称)<br /> <br /> <br /> <br /> <br /> <br />     ' 当前任务完成<br />     任务json.置整数 (“[” ＋ 到文本 (当前执行任务id) ＋ “]startTime”, 任务json.取整数 (“[” ＋ 到文本 (当前执行任务id) ＋ “].delay”) ＋ 到整数 (时间_取现行时间戳 (真)))<br /> <br /> .如果真结束

huang337588

我自己有个非常愚蠢的思路，我准备把每个任务都 做到 每个按钮事件上，然后哪个到时候了  就单击哪个按钮，哈哈哈

cobi

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
s	整数型
任务时间	整数型	0

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

任务时间 ＝ { 1600, 600, 1200, 1300, 1700, 900, 1400, 1500 }  ' 初始任务的刷新时间，每个排序任务刷新时间放到数组
时钟1.时钟周期 ＝ 1000  ' 设置时钟1秒运行一次

子程序名	返回值类型	公开	备 注
_时钟1_周期事件

变量名	类 型	静态	数组	备 注
i	整数型

如果真 (s ＞ 1700)  ' 设置一个最大刷新时间，对应任务最大时间值，当时钟运行到最大值后初始重新计时
s ＝ 0
s ＝ s ＋ 1
计次循环首 (取数组成员数 (), i)
如果真 (任务时间 [i] ＝ s)
执行任务 (i)
跳出循环 ()

计次循环尾 ()

子程序名	返回值类型	公开	备 注
执行任务
参数名	类 型	参考	可空	数组	备 注
任务序号	整数型				对应刷新时间组的顺序

判断 (任务序号 ＝ 1)
' 执行 1.任务
判断 (任务序号 ＝ 2)
' 执行 2.任务
判断 (任务序号 ＝ 3)
' 执行 3.任务
判断 (任务序号 ＝ 4)
' 执行 4.任务
判断 (任务序号 ＝ 5)
' 执行 5.任务
判断 (任务序号 ＝ 6)
' 执行 6.任务
判断 (任务序号 ＝ 7)
' 执行 7.任务
判断 (任务序号 ＝ 8)
' 执行 8.任务
' 以此类推

.版本 2<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 s, 整数型<br /> .程序集变量 任务时间, 整数型, , "0"<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> 任务时间 ＝ { 1600, 600, 1200, 1300, 1700, 900, 1400, 1500 }  ' 初始任务的刷新时间，每个排序任务刷新时间放到数组<br /> 时钟1.时钟周期 ＝ 1000  ' 设置时钟1秒运行一次<br /> <br /> .子程序 _时钟1_周期事件<br /> .局部变量 i, 整数型<br /> <br /> .如果真 (s ＞ 1700)  ' 设置一个最大刷新时间，对应任务最大时间值，当时钟运行到最大值后初始重新计时<br />     s ＝ 0<br /> .如果真结束<br /> s ＝ s ＋ 1<br /> .计次循环首 (取数组成员数 (), i)<br />     .如果真 (任务时间 <i> ＝ s)<br />         执行任务 (i)<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> .子程序 执行任务<br /> .参数 任务序号, 整数型, , 对应刷新时间组的顺序<br /> <br /> .判断开始 (任务序号 ＝ 1)<br />     ' 执行 1.任务<br /> .判断 (任务序号 ＝ 2)<br />     ' 执行 2.任务<br /> .判断 (任务序号 ＝ 3)<br />     ' 执行 3.任务<br /> .判断 (任务序号 ＝ 4)<br />     ' 执行 4.任务<br /> .判断 (任务序号 ＝ 5)<br />     ' 执行 5.任务<br /> .判断 (任务序号 ＝ 6)<br />     ' 执行 6.任务<br /> .判断 (任务序号 ＝ 7)<br />     ' 执行 7.任务<br /> .判断 (任务序号 ＝ 8)<br />     ' 执行 8.任务<br /> .默认<br />     ' 以此类推

补充内容 (2025-5-5 04:44):
取数组成员数 () 忘记加入数组了，应改为：
计次循环首 (取数组成员数 (任务时间), i)

补充内容 (2025-5-5 04:47):
你也可以设置一个按钮事件来执行 __启动窗口_创建完毕 子程序里的代码，当按钮按下更改 按钮标题，用标题来判断 是否开启或停止

补充内容 (2025-5-5 04:49):
按钮事件中设置时钟周期时间就能停止或开启，时钟1.时钟周期 = 0 即停止，时钟1.时钟周期 = 1000 即开启。

samll88

写一个全局变量就行了.
当变量等于0进入比如最短的任务,完成以后变量等于1
当变量等于1进入比如第二短的任务,完成以后变量等于2
.......................类推

笨来无一悟

可以同时执行就多线程 不能同时就加入队列

b0y

用一个结构体 记录每个任务的刷新时间 和 上次执行时间
然后用一个线程 来处理任务  线程判断是否已经开始处理任务  是就循环任务数量  判断每个任务上次时间+刷新时间 是否小于现行时间 是则再次做该任务 否则不处理 循环判断下一个任务

huang337588

b0y 发表于 2025-5-5 09:12
用一个结构体 记录每个任务的刷新时间 和 上次执行时间
然后用一个线程 来处理任务  线程判断是否已经开始 ...

我能明白，就是技术不到家，只能用本笨办法

wsangjunhua123

我新手  不知道行不行=。=


.版本 2

.子程序 __启动窗口_创建完毕

时钟1.时钟周期 ＝ 1000
a ＝ 1700
b ＝ 600


.子程序 _时钟1_周期事件

s ＝ s ＋ 1000
.如果真 (取整 (s ÷ a) ＝ s ÷ a)
    ' 执行a
.如果真结束
.如果真 (取整 (s ÷ b) ＝ s ÷ b)
    ' 执行b
.如果真结束

huang337588

wsangjunhua123 发表于 2025-5-5 11:22
我新手  不知道行不行=。=

谢谢，兄弟，这个不行的