精益模块多线程新手学习例子！

黄泉无际

一直对多线程雾里看花。。。

什么许可证，这了那了的。。。很迷茫，教材看了好几个感觉也没什么用，唯一的用处就是更迷茫了。

前两天跟一个大神聊天，大神说了一句：“只要不崩溃，只要没BUG，你搞的再复杂有什么意义？炫技么？”

是啊，既然简简单单就能做到的事情 为什么要复杂化呢？  也许并不完美，也许有人看到嗤之以鼻，我也只能说声，这就是最简单的，最方便的，新手学习是够的！ 最起码懂了什么叫多线程

不再废话，上源码 只用了精益模块，请自行在论坛下载 我就不上传了

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
xcqd1	整数型		主线程线程句柄
xcqd2	逻辑型		主线程关闭是否成功判断
tz	逻辑型		循环逻辑变量
xz2	逻辑型		子线程关闭是否成功判断
xz1	整数型		子线程句柄
gj2	逻辑型
gj1	整数型
cz2	逻辑型
cz1	整数型

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

' ----------------------------------------------------------------------------------------------------------------------------
' 举个简单的例子：以游戏为例   角色行走-线程1   角色攻击-线程2 打怪状态-线程3
' 这样就比较容易理解了 首先 我们的主线程就是我们是不是要开始打怪的控制 启动主线程就开始打怪了
' 而打怪又分为很多操作，
' 比如我们要走着找怪 这时候我们就需要启动  角色行走-
' 找到怪物了我们就又要启动 角色攻击-
' 打怪打死没打死我们又要启动  打怪状态-
' 在单线程中 我们 一般写成  角色行走-角色攻击-打怪状态-  这种线性的操作模式
' 多线程就很简单了 我们就能一边走着一边打怪打着怪还能看看怪打死了没有 这就是多线程的便利之处了

子程序名	返回值类型	公开	备 注
_按钮1_被单击			启动键

tz ＝ 假  ' 循环判断条件
xcqd1 ＝ 线程_启动 (&xcqd, , xcqd1)  ' xcqd1（主线程句柄） &xcqd（主线程程序） xcqd1（主线程句柄）

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

tz ＝ 真  ' 循环判断条件
xz2 ＝ 线程_销毁 (xz1)  ' 停止角色行走线程
gj2 ＝ 线程_销毁 (gj1)  ' 停止角色攻击线程
cz2 ＝ 线程_销毁 (cz1)  ' 停止打怪状态线程

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

tz ＝ 假  ' 循环判断条件
xz1 ＝ 线程_启动 (&xz0, , xz1)  ' xz1（角色行走-线程句柄） &xz0（角色行走-程序） xz1（角色行走-线程句柄）
gj1 ＝ 线程_启动 (&gj0, , gj1)  ' gj1（角色攻击-线程句柄） gj0（角色攻击-程序）gj1（角色攻击-线程句柄）
cz1 ＝ 线程_启动 (&cz0, , cz1)  ' cz1（打怪状态-线程句柄） cz0（打怪状态-程序）cz1（打怪状态-线程句柄）
' xcqd2 ＝ 线程_销毁 (xcqd1)  ' 停止主程序线程否则主程序进程会重复启动子线程

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

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

循环判断首 ()
s ＝ s ＋ 1
调试输出 (“角色行走”, xz1, s)
程序_延时 (2, 1)
循环判断尾 (tz ＝ 假)

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

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

循环判断首 ()
s ＝ s ＋ 1
调试输出 (“角色攻击”, gj1, s)
程序_延时 (2, 1)
循环判断尾 (tz ＝ 假)

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

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

循环判断首 ()
s ＝ s ＋ 1
调试输出 (“打怪状态”, cz1, s)
程序_延时 (2, 1)
循环判断尾 (tz ＝ 假)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 xcqd1, 整数型, , , 主线程线程句柄<br /> .程序集变量 xcqd2, 逻辑型, , , 主线程关闭是否成功判断<br /> .程序集变量 tz, 逻辑型, , , 循环逻辑变量<br /> .程序集变量 xz2, 逻辑型, , , 子线程关闭是否成功判断<br /> .程序集变量 xz1, 整数型, , , 子线程句柄<br /> .程序集变量 gj2, 逻辑型<br /> .程序集变量 gj1, 整数型<br /> .程序集变量 cz2, 逻辑型<br /> .程序集变量 cz1, 整数型<br /> <br /> .子程序 __启动窗口_创建完毕<br /> <br /> ' ----------------------------------------------------------------------------------------------------------------------------<br /> ' 举个简单的例子：以游戏为例   角色行走-线程1   角色攻击-线程2 打怪状态-线程3<br /> ' 这样就比较容易理解了 首先 我们的主线程就是我们是不是要开始打怪的控制 启动主线程就开始打怪了<br /> ' 而打怪又分为很多操作，<br /> ' 比如我们要走着找怪 这时候我们就需要启动  角色行走-<br /> ' 找到怪物了我们就又要启动 角色攻击-<br /> ' 打怪打死没打死我们又要启动  打怪状态-<br /> ' 在单线程中 我们 一般写成  角色行走-角色攻击-打怪状态-  这种线性的操作模式<br /> ' 多线程就很简单了 我们就能一边走着一边打怪打着怪还能看看怪打死了没有 这就是多线程的便利之处了<br /> <br /> <br /> .子程序 _按钮1_被单击, , , 启动键<br /> <br /> tz ＝ 假  ' 循环判断条件<br /> <br /> xcqd1 ＝ 线程_启动 (&xcqd, , xcqd1)  ' xcqd1（主线程句柄） &xcqd（主线程程序） xcqd1（主线程句柄）<br /> <br /> <br /> .子程序 _按钮2_被单击, , , 停止键<br /> <br /> tz ＝ 真  ' 循环判断条件<br /> <br /> xz2 ＝ 线程_销毁 (xz1)  ' 停止角色行走线程<br /> <br /> gj2 ＝ 线程_销毁 (gj1)  ' 停止角色攻击线程<br /> <br /> cz2 ＝ 线程_销毁 (cz1)  ' 停止打怪状态线程<br /> <br /> <br /> .子程序 xcqd, , , 主线程程序<br /> <br /> tz ＝ 假  ' 循环判断条件<br /> xz1 ＝ 线程_启动 (&xz0, , xz1)  ' xz1（角色行走-线程句柄） &xz0（角色行走-程序） xz1（角色行走-线程句柄）<br /> <br /> gj1 ＝ 线程_启动 (&gj0, , gj1)  ' gj1（角色攻击-线程句柄） gj0（角色攻击-程序）gj1（角色攻击-线程句柄）<br /> <br /> cz1 ＝ 线程_启动 (&cz0, , cz1)  ' cz1（打怪状态-线程句柄） cz0（打怪状态-程序）cz1（打怪状态-线程句柄）<br /> <br /> <br /> ' xcqd2 ＝ 线程_销毁 (xcqd1)  ' 停止主程序线程否则主程序进程会重复启动子线程<br /> <br /> <br /> .子程序 xz0<br /> .局部变量 s, 整数型<br /> <br /> .循环判断首 ()<br />     s ＝ s ＋ 1<br />     调试输出 (“角色行走”, xz1, s)<br /> <br />     程序_延时 (2, 1)<br /> <br /> .循环判断尾 (tz ＝ 假)<br /> <br /> <br /> <br /> .子程序 gj0<br /> .局部变量 s, 整数型<br /> <br /> <br /> .循环判断首 ()<br />     s ＝ s ＋ 1<br />     调试输出 (“角色攻击”, gj1, s)<br />     程序_延时 (2, 1)<br /> <br /> <br /> .循环判断尾 (tz ＝ 假)<br /> <br /> .子程序 cz0<br /> .局部变量 s, 整数型<br /> <br /> <br /> .循环判断首 ()<br />     s ＝ s ＋ 1<br />     调试输出 (“打怪状态”, cz1, s)<br />     程序_延时 (2, 1)<br /> <br /> .循环判断尾 (tz ＝ 假)

lenye

感谢楼主分享经验

freeocean

赠人玫瑰手有余香

freeocean

zr赠人玫瑰手有余香

552233

支持开源~！感谢分享

552233

支持开源~！感谢分享

tellmesy

感谢分享         

黄泉无际

.版本 2
.支持库 spec

.程序集 窗口程序集_启动窗口
.程序集变量 xcqd1, 整数型, , , 主线程线程句柄
.程序集变量 xcqd2, 逻辑型, , , 主线程关闭是否成功判断
.程序集变量 tz, 逻辑型, , , 循环逻辑变量
.程序集变量 xz2, 逻辑型, , , 子线程关闭是否成功判断
.程序集变量 xz1, 整数型, , , 子线程句柄
.程序集变量 gj2, 逻辑型
.程序集变量 gj1, 整数型
.程序集变量 cz2, 逻辑型
.程序集变量 cz1, 整数型
.程序集变量 xkz1, 线程许可证
.程序集变量 xkz2, 线程许可证
.程序集变量 xkz3, 线程许可证

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

' ----------------------------------------------------------------------------------------------------------------------------
' 举个简单的例子：以游戏为例   角色行走-线程1   角色攻击-线程2 打怪状态-线程3
' 这样就比较容易理解了 首先 我们的主线程就是我们是不是要开始打怪的控制 启动主线程就开始打怪了
' 而打怪又分为很多操作，
' 比如我们要走着找怪 这时候我们就需要启动  角色行走-
' 找到怪物了我们就又要启动 角色攻击-
' 打怪打死没打死我们又要启动  打怪状态-
' 在单线程中 我们 一般写成  角色行走-角色攻击-打怪状态-  这种线性的操作模式
' 多线程就很简单了 我们就能一边走着一边打怪打着怪还能看看怪打死了没有 这就是多线程的便利之处了


xkz1 ＝ 线程_创建许可证 ()  ' 创建每个线程的许可证，防止线程重复启动
xkz2 ＝ 线程_创建许可证 ()
xkz3 ＝ 线程_创建许可证 ()



.子程序 _按钮1_被单击, , , 启动键

tz ＝ 假  ' 循环判断条件

xcqd1 ＝ 线程_启动 (&xcqd, , xcqd1)  ' xcqd1（主线程句柄） &xcqd（主线程程序） xcqd1（主线程句柄）


.子程序 _按钮2_被单击, , , 停止键

tz ＝ 真  ' 循环判断条件
xz2 ＝ 线程_销毁 (xz1)  ' 停止角色行走线程

gj2 ＝ 线程_销毁 (gj1)  ' 停止角色攻击线程

cz2 ＝ 线程_销毁 (cz1)  ' 停止打怪状态线程


.子程序 xcqd, , , 主线程程序

tz ＝ 假  ' 循环判断条件
线程_进入许可区 (xkz1)  ' 进入创建好的许可证，当我们的跳出循环条件达成就会进行下一步退出许可证
xz1 ＝ 线程_启动 (&xz0, , xz1)  ' xz1（角色行走-线程句柄） &xz0（角色行走-程序） xz1（角色行走-线程句柄）
线程_退出许可区 (xkz1)  ' 循环条件达成退出许可证

线程_进入许可区 (xkz2)
gj1 ＝ 线程_启动 (&gj0, , gj1)  ' gj1（角色攻击-线程句柄） gj0（角色攻击-程序）gj1（角色攻击-线程句柄）
线程_退出许可区 (xkz2)

线程_进入许可区 (xkz3)
cz1 ＝ 线程_启动 (&cz0, , cz1)  ' cz1（打怪状态-线程句柄） cz0（打怪状态-程序）cz1（打怪状态-线程句柄）
线程_退出许可区 (xkz3)




.子程序 xz0
.局部变量 s, 整数型

.循环判断首 ()
    s ＝ s ＋ 1
    调试输出 (“角色行走”, xz1, s)

    程序_延时 (10, 0)

.循环判断尾 (tz ＝ 假)



.子程序 gj0
.局部变量 s, 整数型


.循环判断首 ()
    s ＝ s ＋ 1
    调试输出 (“角色攻击”, gj1, s)
    程序_延时 (10, 0)


.循环判断尾 (tz ＝ 假)

.子程序 cz0
.局部变量 s, 整数型


.循环判断首 ()
    s ＝ s ＋ 1
    调试输出 (“打怪状态”, cz1, s)
    程序_延时 (10, 0)

.循环判断尾 (tz ＝ 假)

.子程序 __启动窗口_将被销毁


线程_删除许可证 (xkz1)
线程_删除许可证 (xkz2)
线程_删除许可证 (xkz3)

QS171333

552233

感谢楼主分享经验