鱼刺线程池 多线程拨号代码

鱼刺线程池 多线程拨号代码

@L1yp

.版本 2

.程序集 启动
.程序集变量 xxx, _魔改的线程池
.程序集变量 LoginArr, _XX协议登录, , "0"
.程序集变量 集_运行, 逻辑型

.子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码

.如果真 (是否为调试版 () ＝ 真)
    输出调试文本 (#注释)
.如果真结束
_临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
返回 (0)  ' 可以根据您的需要返回任意数值

.子程序 _临时子程序
.局部变量 i, 整数型
.局部变量 登录N个号拨号, 整数型
.局部变量 拨号结果, 逻辑型

' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
' 需求:比如有1W个帐号 5线程登录 每登录15个 就拨号
' 1. 初始化 这个数组
重定义数组 (LoginArr, 假, 100)
.计次循环首 (取数组成员数 (LoginArr), i)
    LoginArr [i].初始化 (到文本 (1000000 ＋ i), 到文本 (2000000 ＋ i))
.计次循环尾 ()
xxx.创建 (10, 10)
登录N个号拨号 ＝ 30
集_运行 ＝ 真
i ＝ 0

.判断循环首 (集_运行)
    i ＝ i ＋ 1
    xxx.投递任务 (&任务子程序, i)
    .如果真 (i ％ 登录N个号拨号 ＝ 0 或 i ＝ 取数组成员数 (LoginArr))
        输出调试文本 (“投递任务OK 等待运行完毕”)
        xxx.等待运行完毕 ()  ' 阻塞等待线程池中 队列执行完毕 然后拨号
        .如果真 (i ＝ 取数组成员数 (LoginArr))
            输出调试文本 (“运行完毕拉”)
            跳出循环 ()
        .如果真结束
        输出调试文本 (“本批次执行完毕, 等待拨号完毕后 登录下一批”)
        拨号结果 ＝ 拨号子程序 ()  ' 返回拨号结果
        .如果真 (取反 (拨号结果))  ' 如果拨号失败 那就结束吧
            跳出循环 ()
        .如果真结束
        输出调试文本 (“拨号结束 即将投递下一批”)
    .如果真结束

.判断循环尾 ()

.子程序 任务子程序
.参数 ID, 整数型

.判断开始 (LoginArr [ID].登录 ())
    输出调试文本 (“[” ＋ 到文本 (ID) ＋ “] -> [” ＋ LoginArr [ID].取帐号 () ＋ “----” ＋ LoginArr [ID].取密码 () ＋ “] -> 登录成功”)
.默认
    输出调试文本 (“[” ＋ 到文本 (ID) ＋ “] -> [” ＋ LoginArr [ID].取帐号 () ＋ “----” ＋ LoginArr [ID].取密码 () ＋ “] -> 登录失败”)
.判断结束


.子程序 拨号子程序, 逻辑型

_延时 (5000)

返回 (真)

.子程序 _测试_缓冲区
.局部变量 int, 整数型
.局部变量 t, 整数型
.局部变量 i, 整数型
.局部变量 addr, 整数型
.局部变量 bin, 字节集

addr ＝ 缓冲区_分配 ()
缓冲区_添加文本 (addr, “123456”)
缓冲区_添加字节集 (addr, 到字节集 (取空白文本 (4096)))
缓冲区_添加文本 (addr, “654321”)
输出调试文本 (缓冲区_取长度 (addr))
bin ＝ 缓冲区_取数据字节集 (addr)
输出调试文本 (到文本 (bin))
输出调试文本 (缓冲区_取数据文本 (addr))
缓冲区_释放 (addr)
返回 ()

t ＝ 取启动时间 ()
.计次循环首 (1000000, i)
    addr ＝ _内存分配 (_取默认堆 (), 8, 8)
    ' addr ＝ _内存页分配 (0, 8, #MEM_COMMIT, 4)
    .如果 (addr ≠ 0)

        _内存释放 (_取默认堆 (), 0, addr)
        ' _内存页释放 (addr, 0, #MEM_RELEASE)

    .否则
        输出调试文本 (“失败”)
    .如果结束


.计次循环尾 ()
t ＝ 取启动时间 () － t
输出调试文本 (i)
输出调试文本 (t)




.子程序 _测试_队列2
.局部变量 q, 鱼刺类_队列, , , queue
.局部变量 t, 整数型
.局部变量 len, 整数型
.局部变量 i, 整数型
.局部变量 _字节, 字节型
.局部变量 _短整数, 短整数型
.局部变量 _整数, 整数型
.局部变量 _长整数, 长整数型
.局部变量 _小数, 小数型
.局部变量 _双精度小数, 双精度小数型
.局部变量 _逻辑, 逻辑型
.局部变量 _日期时间, 日期时间型
.局部变量 _子程序指针, 子程序指针
.局部变量 _文本, 文本型
.局部变量 _字节集, 字节集
.局部变量 _字节返回, 字节型
.局部变量 _短整数返回, 短整数型
.局部变量 _整数返回, 整数型
.局部变量 _长整数返回, 长整数型
.局部变量 _小数返回, 小数型
.局部变量 _双精度小数返回, 双精度小数型
.局部变量 _逻辑返回, 逻辑型
.局部变量 _日期时间返回, 日期时间型
.局部变量 _子程序指针返回, 子程序指针
.局部变量 _文本返回, 文本型
.局部变量 _字节集返回, 字节集

_字节 ＝ 123
_短整数 ＝ 12345
_整数 ＝ 1234567890
_长整数 ＝ 1234567890123
_小数 ＝ 到小数 (“1.2345”)
_双精度小数 ＝ 到数值 (“1.234567890123”)
_逻辑 ＝ 真
_日期时间 ＝ [2038年1月30日]
_子程序指针 ＝ &_测试_队列2

_文本 ＝ “12345678901234567890”
_字节集 ＝ { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 123 }

q.压入字节 (_字节)
q.压入短整数 (_短整数)
q.压入整数 (_整数)
q.压入长整数 (_长整数)
q.压入小数 (_小数)
q.压入双精度小数 (_双精度小数)
q.压入逻辑 (_逻辑)
q.压入日期时间 (_日期时间)
q.压入子程序指针 (_子程序指针)
q.压入文本 (_文本)
q.压入字节集 (_字节集)

q.弹出字节 (_字节返回)
q.弹出短整数 (_短整数返回)
q.弹出整数 (_整数返回)
q.弹出长整数 (_长整数返回)
q.弹出小数 (_小数返回)
q.弹出双精度小数 (_双精度小数返回)
q.弹出逻辑 (_逻辑返回)
q.弹出日期时间 (_日期时间返回)
q.弹出子程序指针 (_子程序指针返回)
q.弹出文本 (_文本返回)
q.弹出字节集 (_字节集返回)

输出调试文本 (_字节返回)
输出调试文本 (_短整数返回)
输出调试文本 (_整数返回)
输出调试文本 (_长整数返回)
输出调试文本 (_小数返回)
输出调试文本 (_双精度小数返回)
输出调试文本 (_逻辑返回)
输出调试文本 (_日期时间返回)
输出调试文本 (到整数 (_子程序指针返回))
输出调试文本 (_文本返回)
输出调试文本 (取字节集长度 (_字节集返回))
返回 ()


len ＝ 1000000  ' 100W
q.置默认缓冲区大小 (1024 × 1024 × 4)
t ＝ 取启动时间 ()
.计次循环首 (len, i)
    q.压入整数 (i)
.计次循环尾 ()
len ＝ q.取数量 ()
.计次循环首 (len, i)
    q.弹出整数 (i)
.计次循环尾 ()
t ＝ 取启动时间 () － t
输出调试文本 (len)
输出调试文本 (i)
输出调试文本 (“整数 压入完弹出用时：” ＋ 到文本 (t))

返回 ()

_字节集 ＝ 到字节集 (“鱼刺 你又调皮了唉！”)
t ＝ 取启动时间 ()
.计次循环首 (len, i)
    q.压入字节集 (_字节集)
.计次循环尾 ()
.计次循环首 (q.取数量 (), i)
    q.弹出字节集 (_字节集)
.计次循环尾 ()
t ＝ 取启动时间 () － t
输出调试文本 (到文本 (_字节集))
输出调试文本 (i)
输出调试文本 (“字节集 压入完弹出用时：” ＋ 到文本 (t))



.子程序 _测试_队列1
.局部变量 队列2, 鱼刺类_队列
.局部变量 t, 整数型
.局部变量 bin, 字节集
.局部变量 len, 整数型
.局部变量 i, 整数型


len ＝ 1000000  ' 100W
t ＝ 取启动时间 ()
.计次循环首 (len, i)
    队列2.压入整数 (i)
.计次循环尾 ()
.计次循环首 (len, i)
    队列2.弹出整数 (i)
.计次循环尾 ()
t ＝ 取启动时间 () － t
输出调试文本 (“整数 压入完弹出用时：” ＋ 到文本 (t))
返回 ()

bin ＝ 到字节集 (“鱼刺 你又调皮了唉！”)
t ＝ 取启动时间 ()
.计次循环首 (len, i)
    队列2.压入字节集 (bin)
.计次循环尾 ()
.计次循环首 (队列2.取数量 (), i)
    队列2.弹出字节集 (bin)
.计次循环尾 ()
t ＝ 取启动时间 () － t
输出调试文本 (到文本 (bin))
输出调试文本 (i)
输出调试文本 (“字节集 压入完弹出用时：” ＋ 到文本 (t))



.子程序 Demo
.局部变量 线程, 鱼刺类_线程操作
.局部变量 临界, 鱼刺类_临界许可
.局部变量 互斥, 鱼刺类_互斥锁
.局部变量 事件, 鱼刺类_事件
.局部变量 信号, 鱼刺类_信号量
.局部变量 原子, 鱼刺类_原子锁
.局部变量 线程池, 鱼刺类_线程池
.局部变量 线程池Ex, 鱼刺类_线程池Ex
.局部变量 读写锁1, 鱼刺类_读写锁
.局部变量 线程池_自销毁, 鱼刺类_线程池_自销毁
.局部变量 bool, 逻辑型
.局部变量 int, 整数型
.局部变量 临界许可, 临界许可
.局部变量 ret, 整数型


bool ＝ 线程.创建 (&Demo_Thread)
.判断循环首 (线程.是否已创建 () ＝ 真)
    线程.等待 (10)
    _延迟 (10)
    线程.等待2 (20)
    线程.等待_msg (20)
.判断循环尾 ()
线程.投递信息A (0, 0, 0)
线程.投递信息W (0, 0, 0)
输出调试文本 (“线程操作”, bool)


临界.进入 ()
处理事件 ()
临界.退出 ()
输出调试文本 (“临界许可”)


bool ＝ 互斥.创建 ()
互斥.进入 ()
处理事件 ()
互斥.退出 ()
互斥.关闭 ()
输出调试文本 (“互斥”, bool)


bool ＝ 事件.创建 ()
事件.触发 ()
处理事件 ()
事件.等待进入 ()
事件.关闭 ()
输出调试文本 (“事件对象”, bool)


bool ＝ 信号.创建 (1, 2)
信号.增加 (1)
信号.递减 ()
信号.关闭 ()
输出调试文本 (“信号量”, bool)


原子.递增 ()
原子.赋值 (2)
原子.运算 (1)
输出调试文本 (“原子锁”, 原子.取值 ())  ' 3

线程池.创建 (2)
线程池.投递任务 (&Demo_Thread, 1)
线程池.取_状态 ()
线程池.取_是否空闲 ()
线程池.取_空闲线程数 ()
线程池.取_执行线程数 ()
线程池.取_队列任务数 ()
线程池.取_线程池容量 ()
bool ＝ 线程池.销毁 (0)
输出调试文本 (“线程池”, bool)


线程池Ex.创建 (2, 3)
线程池Ex.投递任务 (&Demo_Thread, 2)
线程池Ex.等待任务动态 ()
线程池Ex.暂停 ()
线程池Ex.继续 ()
线程池Ex.事件_暂停 ()
线程池Ex.取_状态 ()
线程池Ex.取_是否空闲 ()
线程池Ex.取_空闲线程数 ()
线程池Ex.取_执行线程数 ()
线程池Ex.取_队列任务数 ()
线程池Ex.取_线程池容量 ()
线程池Ex.置_最大线程数 (3)
线程池Ex.置_空闲回收时间 (100)
bool ＝ 线程池Ex.销毁 (0)
输出调试文本 (“鱼翅类.线程池Ex”, bool)


bool ＝ 读写锁1.读锁定 ()
读写锁1.解锁 ()
bool ＝ 读写锁1.写锁定 ()
读写锁1.解锁 ()
输出调试文本 (“读写锁”, bool)

输出调试文本 (“--------------------------------”)

bool ＝ 线程_创建 (&Demo_Thread, , int)
线程_挂起 (int)
输出调试文本 (“挂起后状态”, _对象等待 (int, 0))
线程_恢复 (int)
bool ＝ 线程_等待 (int, 5000)
线程_关闭句柄 (int)
输出调试文本 (“线程”, int, bool)


int ＝ _创建进入许可证 ()
_进入许可区 (int)
处理事件 ()
_退出许可区 (int)
_删除进入许可证 (int)
输出调试文本 (“许可证”, int)


临界许可 ＝ 临界_创建 ()
临界_进入 (临界许可)
临界_退出 (临界许可)
临界_销毁 (临界许可)
输出调试文本 (“临界”, 临界许可.标识)


int ＝ 互斥_创建 ()
互斥_进入 (int)
互斥_退出 (int)
互斥_关闭 (int)
输出调试文本 (“互斥量”, int)


int ＝ 事件_创建 ()
事件_触发 (int)
事件_等待进入 (int)
事件_关闭 (int)
输出调试文本 (“事件对象”, int)


int ＝ 信号量_创建 (1, 2)
信号量_增加 (int, 1)
信号量_递减 (int)
信号量_关闭 (int)
输出调试文本 (“信号量”, int)

原子_赋值 (int, 0)
原子_递增 (int)
原子_递减 (int)
原子_运算 (int, 1)
原子_判断赋值 (int, 0, 1)
原子_相加_asm (int, 1)
原子_相减_asm (int, 1)
输出调试文本 (“原子锁”, int)

int ＝ 线程池_创建 (2)
线程池_投递任务 (int, &Demo_Thread, 1)
线程池_取状态 (int)
线程池_取_是否空闲 (int)
线程池_取_空闲线程数 (int)
线程池_取_执行线程数 (int)
线程池_取_队列任务数 (int)
线程池_取_线程池容量 (int)
线程池_销毁 (int, 0)
输出调试文本 (“线程池”, int)


int ＝ 线程池Ex_创建 (2, 3)
线程池Ex_投递任务 (int, &Demo_Thread, 1)
线程池Ex_投递任务 (int, &Demo_Thread, 1)
线程池Ex_暂停 (int)
线程池Ex_继续 (int)
线程池Ex_事件_暂停 (int)
线程池Ex_等待任务动态 (int, 5000)
线程池Ex_取状态 (int)
线程池Ex_取_是否空闲 (int)
线程池Ex_取_空闲线程数 (int)
线程池Ex_取_执行线程数 (int)
线程池Ex_取_队列任务数 (int)
线程池Ex_取_线程池容量 (int)
线程池Ex_置_最大线程数 (int, 3)
线程池Ex_置_空闲回收时间 (int, 100)
线程池Ex_销毁 (int, 0)
输出调试文本 (“线程池Ex”, int)

int ＝ 读写锁_创建 ()
读写锁_读锁定 (int)
读写锁_解锁 (int)
读写锁_写锁定 (int)
读写锁_解锁 (int)
读写锁_销毁 (int)
输出调试文本 (“读写锁”, int)


线程池_自销毁.创建 (2, 100)
线程池_自销毁.置_线程空闲自销毁超时值 (100)
线程池_自销毁.投递任务 (&Demo_Thread, 1)
线程池_自销毁.取_状态 ()
线程池_自销毁.取_是否空闲 ()
线程池_自销毁.取_空闲线程数 ()
线程池_自销毁.取_执行线程数 ()
线程池_自销毁.取_队列任务数 ()
线程池_自销毁.取_线程池容量 ()
bool ＝ 线程池_自销毁.销毁 (0)
输出调试文本 (“线程池_自销毁”, bool)



.子程序 Demo_Thread
.参数 参数, 整数型

_延时 (20)
输出调试文本 (参数)