麻烦帮我优化一下鱼刺类 多线程代码

KD飞飞

感觉自己写错了 运行速度贼慢
一共8个编辑框 每个编辑框三行 内写
1
2
3

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
_线程操作	鱼刺类_线程操作
_线程池	鱼刺类_线程池
词组1	文本型	0
词组2	文本型	0
词组3	文本型	0
词组4	文本型	0
词组5	文本型	0
词组6	文本型	0
词组7	文本型	0
词组8	文本型	0
中间字符	文本型
最终行数	整数型

子程序名	返回值类型	公开	备 注
_按钮2_被单击

中间字符 ＝ “-”
词组1 ＝ 分割文本 (编辑框1.内容, #换行符, )
词组2 ＝ 分割文本 (编辑框2.内容, #换行符, )
词组3 ＝ 分割文本 (编辑框3.内容, #换行符, )
词组4 ＝ 分割文本 (编辑框4.内容, #换行符, )
词组5 ＝ 分割文本 (编辑框5.内容, #换行符, )
词组6 ＝ 分割文本 (编辑框6.内容, #换行符, )
词组7 ＝ 分割文本 (编辑框7.内容, #换行符, )
词组8 ＝ 分割文本 (编辑框8.内容, #换行符, )
最终行数 ＝ 取数组成员数 (词组1) × 取数组成员数 (词组2) × 取数组成员数 (词组3) × 取数组成员数 (词组4) × 取数组成员数 (词组5) × 取数组成员数 (词组6) × 取数组成员数 (词组7) × 取数组成员数 (词组8)
进度条1.位置 ＝ 0
进度条1.最大位置 ＝ 最终行数
_线程操作.创建 (&主线程, , , , , , , , , )

子程序名	返回值类型	公开	备 注
主线程

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

_线程池.创建 (200, , , )
计次循环首 (200, iss)
_线程池.投递任务 (&处理子程序, iss, )
计次循环尾 ()

子程序名	返回值类型	公开	备 注
处理子程序
参数名	类 型	参考	可空	数组	备 注
定位文件	整数型

变量名	类 型	静态	数组	备 注
a	整数型
a2	整数型
a3	整数型
a4	整数型
a5	整数型
a6	整数型
a7	整数型
a8	整数型
临时容器1	文本型
临时容器2	文本型
临时容器3	文本型
临时容器4	文本型
临时容器5	文本型
临时容器6	文本型
临时容器7	文本型
临时容器8	文本型
b	整数型
最终容器	文本型

计次循环首 (取数组成员数 (词组1), a)
临时容器1 ＝ 词组1 [a]
计次循环首 (取数组成员数 (词组2), a2)
临时容器2 ＝ 词组2 [a2]
计次循环首 (取数组成员数 (词组3), a3)
临时容器3 ＝ 词组3 [a3]
计次循环首 (取数组成员数 (词组4), a4)
临时容器4 ＝ 词组4 [a4]
计次循环首 (取数组成员数 (词组5), a5)
临时容器5 ＝ 词组5 [a5]
计次循环首 (取数组成员数 (词组6), a6)
临时容器6 ＝ 词组6 [a6]
计次循环首 (取数组成员数 (词组7), a7)
临时容器7 ＝ 词组7 [a7]
计次循环首 (取数组成员数 (词组8), a8)
临时容器8 ＝ 词组8 [a8]
最终容器 ＝ 最终容器 ＋ 临时容器1 ＋ 中间字符 ＋ 临时容器2 ＋ 中间字符 ＋ 临时容器3 ＋ 中间字符 ＋ 临时容器4 ＋ 中间字符 ＋ 临时容器5 ＋ 中间字符 ＋ 临时容器6 ＋ 中间字符 ＋ 临时容器7 ＋ 中间字符 ＋ 临时容器8 ＋ #换行符
b ＝ b ＋ 1
进度条1.位置 ＝ b
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
计次循环尾 ()
如果真 (最终行数 ＝ b)
编辑框9.内容 ＝ 最终容器

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

_线程操作.强制结束 ()

子程序名	返回值类型	公开	备 注
__启动窗口_将被销毁

_线程操作.强制结束 ()

.版本 2<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 _线程操作, 鱼刺类_线程操作<br /> .程序集变量 _线程池, 鱼刺类_线程池<br /> .程序集变量 词组1, 文本型, , "0"<br /> .程序集变量 词组2, 文本型, , "0"<br /> .程序集变量 词组3, 文本型, , "0"<br /> .程序集变量 词组4, 文本型, , "0"<br /> .程序集变量 词组5, 文本型, , "0"<br /> .程序集变量 词组6, 文本型, , "0"<br /> .程序集变量 词组7, 文本型, , "0"<br /> .程序集变量 词组8, 文本型, , "0"<br /> .程序集变量 中间字符, 文本型<br /> .程序集变量 最终行数, 整数型<br /> <br /> .子程序 _按钮2_被单击<br /> <br /> 中间字符 ＝ “-”<br /> 词组1 ＝ 分割文本 (编辑框1.内容, #换行符, )<br /> 词组2 ＝ 分割文本 (编辑框2.内容, #换行符, )<br /> 词组3 ＝ 分割文本 (编辑框3.内容, #换行符, )<br /> 词组4 ＝ 分割文本 (编辑框4.内容, #换行符, )<br /> 词组5 ＝ 分割文本 (编辑框5.内容, #换行符, )<br /> 词组6 ＝ 分割文本 (编辑框6.内容, #换行符, )<br /> 词组7 ＝ 分割文本 (编辑框7.内容, #换行符, )<br /> 词组8 ＝ 分割文本 (编辑框8.内容, #换行符, )<br /> 最终行数 ＝ 取数组成员数 (词组1) × 取数组成员数 (词组2) × 取数组成员数 (词组3) × 取数组成员数 (词组4) × 取数组成员数 (词组5) × 取数组成员数 (词组6) × 取数组成员数 (词组7) × 取数组成员数 (词组8)<br /> 进度条1.位置 ＝ 0<br /> 进度条1.最大位置 ＝ 最终行数<br /> _线程操作.创建 (&主线程, , , , , , , , , )<br /> <br /> .子程序 主线程<br /> .局部变量 iss, 整数型<br /> <br /> _线程池.创建 (200, , , )<br /> .计次循环首 (200, iss)<br />     _线程池.投递任务 (&处理子程序, iss, )<br /> .计次循环尾 ()<br /> <br /> .子程序 处理子程序<br /> .参数 定位文件, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 a2, 整数型<br /> .局部变量 a3, 整数型<br /> .局部变量 a4, 整数型<br /> .局部变量 a5, 整数型<br /> .局部变量 a6, 整数型<br /> .局部变量 a7, 整数型<br /> .局部变量 a8, 整数型<br /> .局部变量 临时容器1, 文本型<br /> .局部变量 临时容器2, 文本型<br /> .局部变量 临时容器3, 文本型<br /> .局部变量 临时容器4, 文本型<br /> .局部变量 临时容器5, 文本型<br /> .局部变量 临时容器6, 文本型<br /> .局部变量 临时容器7, 文本型<br /> .局部变量 临时容器8, 文本型<br /> .局部变量 b, 整数型<br /> .局部变量 最终容器, 文本型<br /> <br /> .计次循环首 (取数组成员数 (词组1), a)<br />     临时容器1 ＝ 词组1 [a]<br />     .计次循环首 (取数组成员数 (词组2), a2)<br />         临时容器2 ＝ 词组2 [a2]<br />         .计次循环首 (取数组成员数 (词组3), a3)<br />             临时容器3 ＝ 词组3 [a3]<br />             .计次循环首 (取数组成员数 (词组4), a4)<br />                 临时容器4 ＝ 词组4 [a4]<br />                 .计次循环首 (取数组成员数 (词组5), a5)<br />                     临时容器5 ＝ 词组5 [a5]<br />                     .计次循环首 (取数组成员数 (词组6), a6)<br />                         临时容器6 ＝ 词组6 [a6]<br />                         .计次循环首 (取数组成员数 (词组7), a7)<br />                             临时容器7 ＝ 词组7 [a7]<br />                             .计次循环首 (取数组成员数 (词组8), a8)<br />                                 临时容器8 ＝ 词组8 [a8]<br />                                 最终容器 ＝ 最终容器 ＋ 临时容器1 ＋ 中间字符 ＋ 临时容器2 ＋ 中间字符 ＋ 临时容器3 ＋ 中间字符 ＋ 临时容器4 ＋ 中间字符 ＋ 临时容器5 ＋ 中间字符 ＋ 临时容器6 ＋ 中间字符 ＋ 临时容器7 ＋ 中间字符 ＋ 临时容器8 ＋ #换行符<br />                                 b ＝ b ＋ 1<br />                                 进度条1.位置 ＝ b<br />                             .计次循环尾 ()<br />                         .计次循环尾 ()<br />                     .计次循环尾 ()<br />                 .计次循环尾 ()<br />             .计次循环尾 ()<br />         .计次循环尾 ()<br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> .如果真 (最终行数 ＝ b)<br />     编辑框9.内容 ＝ 最终容器<br /> .如果真结束<br /> <br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> _线程操作.强制结束 ()<br /> <br /> .子程序 __启动窗口_将被销毁<br /> <br /> _线程操作.强制结束 ()

笨来无一悟

不定长度另类排列 ↓

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
数量长度不定	不定	0

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

' 自定义数据类型[数组套数组] 实现 → 不同长度数组 枚举排列
数据初始化 ()

子程序名	返回值类型	公开	备 注
数据初始化

变量名	类 型	静态	数组	备 注
N	整数型
结果	快速文本对象
缓存	文本型		0

重定义数组 (数量长度不定, 假, 5)
数量长度不定 [1].不定 ＝ 分割文本 (“1,2,3”, “,”, )
数量长度不定 [2].不定 ＝ { “2”, “4”, “6”, “8”, “10” }
数量长度不定 [3].不定 ＝ { “1”, “3”, “5”, “7”, “9”, “11”, “13”, “15”, “17”, “19”, “21” }
数量长度不定 [4].不定 ＝ { “2”, “4”, “6”, “8”, “10”, “12”, “14”, “16”, “18” }
数量长度不定 [5].不定 ＝ { “8”, “13”, “24”, “56”, “78” }
' 实际应用的时候 可以换行符分割文本 再逗号,分割 最后赋值到 [不定] 数组
重定义数组 (缓存, 假, 取数组成员数 (数量长度不定))
排列 (数量长度不定, 结果, 取数组成员数 (数量长度不定), 缓存, )
调试输出 (结果.取文本 (, ))

子程序名	返回值类型	公开	备 注
排列			支持不同长度
参数名	类 型	参考	可空	数组	备 注
原始	不定
返回	快速文本对象
总数	整数型
缓存	文本型				留空
层次	整数型				留空

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

如果真 (层次 ＜ 总数)
层次 ＝ 层次 ＋ 1
判断 (层次 ＝ 1)
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
排列 (原始, 返回, 总数, 缓存, 层次)
计次循环尾 ()
判断 (层次 ＝ 总数)
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
计次循环首 (总数, B)
返回.添加 (缓存 [B], “,”)
计次循环尾 ()
返回.删除字符 (返回.取长度 (), 1)
返回.添加 ( #换行符 )
' 最终的计算结果 根据实际情况 自行处理 咱就写个罗列成文本的例子
计次循环尾 ()
计次循环首 (取数组成员数 (原始 [层次].不定), A)
缓存 [层次] ＝ 原始 [层次].不定 [A]
排列 (原始, 返回, 总数, 缓存, 层次)
计次循环尾 ()

i支持库列表	支持库注释
commobj	通用对象支持库
spec	特殊功能支持库

.版本 2<br /> .支持库 commobj<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 数量长度不定, 不定, , "0"<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> ' 自定义数据类型[数组套数组] 实现 → 不同长度数组 枚举排列<br /> 数据初始化 ()<br /> <br /> .子程序 数据初始化<br /> .局部变量 N, 整数型<br /> .局部变量 结果, 快速文本对象<br /> .局部变量 缓存, 文本型, , "0"<br /> <br /> 重定义数组 (数量长度不定, 假, 5)<br /> 数量长度不定 [1].不定 ＝ 分割文本 (“1,2,3”, “,”, )<br /> 数量长度不定 [2].不定 ＝ { “2”, “4”, “6”, “8”, “10” }<br /> 数量长度不定 [3].不定 ＝ { “1”, “3”, “5”, “7”, “9”, “11”, “13”, “15”, “17”, “19”, “21” }<br /> 数量长度不定 [4].不定 ＝ { “2”, “4”, “6”, “8”, “10”, “12”, “14”, “16”, “18” }<br /> 数量长度不定 [5].不定 ＝ { “8”, “13”, “24”, “56”, “78” }<br /> <br /> ' 实际应用的时候 可以换行符分割文本 再逗号,分割 最后赋值到 [不定] 数组<br /> <br /> 重定义数组 (缓存, 假, 取数组成员数 (数量长度不定))<br /> 排列 (数量长度不定, 结果, 取数组成员数 (数量长度不定), 缓存, )<br /> 调试输出 (结果.取文本 (, ))<br /> <br /> .子程序 排列, , , 支持不同长度<br /> .参数 原始, 不定, 数组<br /> .参数 返回, 快速文本对象, 参考<br /> .参数 总数, 整数型<br /> .参数 缓存, 文本型, 可空 数组, 留空<br /> .参数 层次, 整数型, 可空, 留空<br /> .局部变量 A, 整数型<br /> .局部变量 B, 整数型<br /> <br /> .如果真 (层次 ＜ 总数)<br />     层次 ＝ 层次 ＋ 1<br /> .如果真结束<br /> .判断开始 (层次 ＝ 1)<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         排列 (原始, 返回, 总数, 缓存, 层次)<br />     .计次循环尾 ()<br /> .判断 (层次 ＝ 总数)<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         .计次循环首 (总数, B)<br />             返回.添加 (缓存 [B], “,”)<br />         .计次循环尾 ()<br />         返回.删除字符 (返回.取长度 (), 1)<br />         返回.添加 (#换行符)<br />         ' 最终的计算结果 根据实际情况 自行处理 咱就写个罗列成文本的例子<br />     .计次循环尾 ()<br /> .默认<br />     .计次循环首 (取数组成员数 (原始 [层次].不定), A)<br />         缓存 [层次] ＝ 原始 [层次].不定 [A]<br />         排列 (原始, 返回, 总数, 缓存, 层次)<br />     .计次循环尾 ()<br /> .判断结束

  

数据类型名	公开	备 注
不定
成员名	类 型	传址	数组	备 注
不定	文本型		1	必须数组

.版本 2<br /> <br /> .数据类型 不定<br />     .成员 不定, 文本型, , "1", 必须数组

补充内容 (2025-3-20 14:37):
如果 "结果" 不是局部变量 每次调用之前 加一句 --- 结果.清除文本()

haoren1212

6，代码写的6

算法艺术家

文本直接相加比较慢，你用快速文本对象 ，最终容器 .添加 (临时容器1, 中间字符, 临时容器2, 中间字符, #换行符) 直接添加 别用加号


内存分配加速优化 (假)
Api静态加速优化 ()
然后这俩命令加上 能快不少

是可可吖

这我还真解答不了，没那技术

孤静之美

一头雾水

opphk

我

萧楚楠

笨来无一悟

不定长度 另类组合
https://bbs.125.la/forum.php?mod=viewthread&tid=14788837
(出处: 精易论坛)
早就有了啊~~~看你的代码 是这个意思吧?用内存加速优化 速度很快的

xiaoshuang

这程序写的真66666666