易语言实现多线程验证代理是否有效的代码

载入程序

				?

									.版本 2

									.程序集 启动

									.子程序 _启动子程序, 整数型

									载入 (_主窗口, , 假)

									返回 (0)

多线程的方式验证ip的代码

此功能需要加载鱼刺类_线程操作模块和鱼刺类_HTTP模块

				?

									.版本 2

									.支持库 iext

									.程序集 主窗口程序集

									.程序集变量 线程池, 鱼刺类_线程池Ex, , , 框架

									.程序集变量 临界, 鱼刺类_临界许可

									.程序集变量 线程, 鱼刺类_线程操作

									.程序集变量 验证网址, 文本型, , , 配置

									.程序集变量 验证字符串, 文本型

									.程序集变量 是否UTF解码, 逻辑型

									.程序集变量 连接超时, 整数型

									.程序集变量 验证超时, 整数型

									.程序集变量 已完成数量, 整数型, , , 记录

									.程序集变量 有效数量, 整数型

									.程序集变量 失效数量, 整数型

									.程序集变量 保证显示索引, 整数型

									.子程序 _按钮_测试_被单击

									.局部变量 测试, 鱼刺类_线程操作, 静态

									.局部变量 bool, 逻辑型

									按钮_测试.禁止 ＝ 真

									验证网址 ＝ 编辑框_验证网址.内容

									验证字符串 ＝ 编辑框_验证字符串.内容

									是否UTF解码 ＝ 选择框_UTF解码.选中

									.如果真 (验证网址 ＝ “” 或 验证字符串 ＝ “”)

									  信息框 (“网址或字符串填写错误！”, 48 ＋ 65536, )

									  按钮_测试.禁止 ＝ 假

									  返回 ()

									.如果真结束

									bool ＝ 测试.创建 (&测试验证网址)

									.如果真 (bool ＝ 真)

									  测试.等待2 ()

									  .判断开始 (测试.取返回值 () ＝ 1) ' 利用线程返回状态判断测试是否成功

									    信息框 (“测试成功！验证网址和关键字可用”, 64 ＋ 65536, )

									  .默认

									    信息框 (“测试失败！验证网址和关键字符串不可用”, 48 ＋ 65536, )

									  .判断结束

									.如果真结束

									按钮_测试.禁止 ＝ 假

									.子程序 测试验证网址, 整数型

									.局部变量 http, WinHttp

									.局部变量 str, 文本型

									http.Open (“GET”, 验证网址)

									http.Set_User_Agent ()

									http.Send ()

									.判断开始 (是否UTF解码 ＝ 真)

									  str ＝ http.GetResponseTextUtf8 ()

									.默认

									  str ＝ http.GetResponseText ()

									.判断结束

									.如果真 (寻找文本 (str, 验证字符串, , 假) ≠ -1)

									  返回 (1) ' 返回状态用于判断是否成功

									.如果真结束

									返回 (0)

									.子程序 _按钮_导入_被单击

									.局部变量 int, 整数型

									.局部变量 str, 文本型

									.局部变量 strs, 文本型, , "0"

									.局部变量 ip, 文本型

									.局部变量 端口, 文本型

									.局部变量 o, 整数型

									通用对话框_浏览.类型 ＝ 0

									通用对话框_浏览.过滤器 ＝ “文本文档（*.txt）|*.txt”

									.如果真 (通用对话框_浏览.打开 () ＝ 假)

									  返回 ()

									.如果真结束

									按钮_导入.禁止 ＝ 真

									int ＝ 打开文件 (通用对话框_浏览.文件名, 1, )

									.如果真 (int ＝ 0)

									  按钮_导入.禁止 ＝ 假

									  返回 ()

									.如果真结束

									.判断循环首 (是否在文件尾 (int, ) ＝ 假)

									  str ＝ 读入一行 (int)

									  str ＝ 删首尾空 (str)

									  strs ＝ 分割文本 (str, “:”, 2)

									  .如果真 (取数组成员数 (strs) ＝ 2)

									    ip ＝ strs [1]

									    端口 ＝ strs [2]

									    .如果真 (ip ≠ “” 且 端口 ≠ “”)

									      o ＝ 列表_代理.插入表项 (, , , 0, , )

									      列表_代理.置标题 (o, 0, 到文本 (o ＋ 1))

									      列表_代理.置标题 (o, 1, ip)

									      列表_代理.置标题 (o, 2, 端口)

									      列表_代理.置标题 (o, 3, “**”)

									      列表_代理.置标题 (o, 4, “-”)

									      _处理事件 ()

									    .如果真结束

									  .如果真结束

									.判断循环尾 ()

									关闭文件 (int)

									状态条_状态.置文本 (0, “代理总数：” ＋ 到文本 (列表_代理.取表项数 ()))

									按钮_导入.禁止 ＝ 假

									.子程序 _按钮_导出_被单击

									.局部变量 bool, 逻辑型

									.局部变量 i, 整数型

									.局部变量 int, 整数型

									.局部变量 ip, 文本型

									.局部变量 端口, 文本型

									.局部变量 time, 文本型

									.局部变量 stop, 文本型

									.局部变量 text, 文本型

									.局部变量 len, 整数型

									.如果真 (列表_代理.取表项数 () ＜ 1)

									  信息框 (“没代理可导出”, 48 ＋ 65536, , )

									  返回 ()

									.如果真结束

									bool ＝ 信息框 (“是否只导出有效代理”, #是否钮 ＋ 48 ＋ 65536, ) ＝ #是钮

									通用对话框_浏览.类型 ＝ 1

									通用对话框_浏览.过滤器 ＝ “文本文档（*.txt）|*.txt”

									.如果真 (通用对话框_浏览.打开 () ＝ 假)

									  返回 ()

									.如果真结束

									按钮_导出.禁止 ＝ 真

									int ＝ 打开文件 (通用对话框_浏览.文件名, 4, )

									移到文件尾 (int)

									.变量循环首 (0, 列表_代理.取表项数 () － 1, 1, i)

									  _处理事件 ()

									  stop ＝ 列表_代理.取标题 (i, 4)

									  .如果真 (bool ＝ 真 且 stop ≠ “验证成功”)

									    到循环尾 ()

									  .如果真结束

									  ip ＝ 列表_代理.取标题 (i, 1)

									  端口 ＝ 列表_代理.取标题 (i, 2)

									  time ＝ 列表_代理.取标题 (i, 3)

									  text ＝ ip ＋ “:” ＋ 端口 ＋ “----” ＋ time

									  .如果真 (bool ＝ 假)

									    text ＝ text ＋ “----” ＋ stop

									  .如果真结束

									  写文本行 (int, text)

									  len ＝ len ＋ 1

									.变量循环尾 ()

									关闭文件 (int)

									信息框 (“保存：” ＋ 通用对话框_浏览.文件名 ＋ “ 成功！” ＋ #换行符 ＋ “共导出：” ＋ 到文本 (len) ＋ “ 条。”, 64 ＋ 65536, )

									按钮_导出.禁止 ＝ 假

									.子程序 _按钮_开始停止_被单击

									.局部变量 text, 文本型

									.局部变量 bool, 逻辑型

									.局部变量 len, 整数型

									按钮_开始停止.禁止 ＝ 真

									text ＝ 按钮_开始停止.标题

									.判断开始 (text ＝ “开始验证”)

									  len ＝ 列表_代理.取表项数 ()

									  .如果真 (len ＜ 1)

									    信息框 (“请先导入要验证的代理”, 48 ＋ 65536, )

									    按钮_开始停止.禁止 ＝ 假

									    返回 ()

									  .如果真结束

									  验证网址 ＝ 删首尾空 (编辑框_验证网址.内容)

									  验证字符串 ＝ 编辑框_验证字符串.内容

									  .如果真 (验证网址 ＝ “” 或 验证字符串 ＝ “”)

									    信息框 (“验证网址或字符串不正确！”, 48 ＋ 65536, )

									    按钮_开始停止.禁止 ＝ 假

									    返回 ()

									  .如果真结束

									  是否UTF解码 ＝ 选择框_UTF解码.选中

									  连接超时 ＝ 到整数 (编辑框_连接超时.内容)

									  验证超时 ＝ 到整数 (编辑框_验证超时.内容)

									  连续赋值 (0, 已完成数量, 有效数量, 失效数量, 保证显示索引)

									  更新状态条 ()

									  bool ＝ 线程.创建 (&工作)

									  .如果真 (bool ＝ 真)

									    返回 ()

									  .如果真结束

									.判断 (text ＝ “停止验证”)

									  按钮_开始停止.标题 ＝ “正在停止”

									  按钮_暂停继续.禁止 ＝ 真

									  按钮_暂停继续.标题 ＝ “暂停验证”

									  线程池.销毁 (0)

									  线程.等待2 ()

									  按钮_开始停止.标题 ＝ “开始验证”

									.默认

									.判断结束

									按钮_开始停止.禁止 ＝ 假

									.子程序 _按钮_暂停继续_被单击

									.局部变量 text, 文本型

									按钮_暂停继续.禁止 ＝ 真

									text ＝ 按钮_暂停继续.标题

									.判断开始 (text ＝ “暂停验证”)

									  线程池.暂停 ()

									  按钮_暂停继续.标题 ＝ “继续验证”

									.判断 (text ＝ “继续验证”)

									  线程池.继续 ()

									  按钮_暂停继续.标题 ＝ “暂停验证”

									.默认

									.判断结束

									按钮_暂停继续.禁止 ＝ 假

									.子程序 工作

									.局部变量 并发线程数, 整数型

									.局部变量 bool, 逻辑型

									.局部变量 len, 整数型

									.局部变量 i, 整数型

									.局部变量 空闲线程数, 整数型

									.局部变量 int, 整数型

									按钮_开始停止.标题 ＝ “正在启动”

									.如果真 (连接超时 ＜ 500)

									  连接超时 ＝ 500

									.如果真结束

									.如果真 (验证超时 ＜ 500)

									  验证超时 ＝ 500

									.如果真结束

									临界.进入 ()

									并发线程数 ＝ 到整数 (编辑框_并发线程数.内容)

									临界.退出 ()

									.如果真 (并发线程数 ＜ 1)

									  并发线程数 ＝ 1

									.如果真结束

									bool ＝ 线程池.创建 (并发线程数)

									.如果真 (bool ＝ 假)

									  临界.进入 ()

									  按钮_开始停止.标题 ＝ “开始验证”

									  按钮_开始停止.禁止 ＝ 假

									  临界.退出 ()

									  返回 ()

									.如果真结束

									临界.进入 ()

									按钮_开始停止.标题 ＝ “停止验证”

									按钮_开始停止.禁止 ＝ 假

									按钮_暂停继续.标题 ＝ “暂停验证”

									按钮_暂停继续.禁止 ＝ 假

									len ＝ 列表_代理.取表项数 () － 1 ' 列表索引从0开始

									临界.退出 ()

									i ＝ 0

									.判断循环首 (i ≤ len)

									  空闲线程数 ＝ 线程池.取_空闲线程数 ()

									  .如果真 (空闲线程数 ＞ 0)

									    int ＝ len － i ＋ 1

									    .如果真 (int ＞ 空闲线程数)

									      int ＝ 空闲线程数

									    .如果真结束

									    .计次循环首 (int, )

									      线程池.投递任务 (&验证子程序, i)

									      i ＝ i ＋ 1

									    .计次循环尾 ()

									  .如果真结束

									  bool ＝ 线程池.等待任务动态 ()

									  .如果真 (bool ＝ 假) ' 返回假 表示线程池被执行销毁 也表示用户手动点了停止

									    返回 ()

									  .如果真结束

									  更新状态条 ()

									.判断循环尾 ()

									' 等待剩余任务执行完毕

									.判断循环首 (线程池.取_是否空闲 () ＝ 假)

									  .如果真 (线程池.取_状态 () ≠ #线程池_正在工作)

									    返回 ()

									  .如果真结束

									  bool ＝ 线程池.等待任务动态 (100)

									  .如果真 (bool ＝ 真)

									    更新状态条 ()

									  .如果真结束

									.判断循环尾 ()

									更新状态条 ()

									' 执行停止

									临界.进入 ()

									按钮_开始停止.禁止 ＝ 真

									按钮_开始停止.标题 ＝ “正在停止”

									按钮_暂停继续.禁止 ＝ 真

									按钮_暂停继续.标题 ＝ “暂停验证”

									临界.退出 ()

									线程池.销毁 (0)

									信息框 (“验证完毕！” ＋ #换行符 ＋ “有效代理：” ＋ 到文本 (有效数量) ＋ #换行符 ＋ “失效代理：” ＋ 到文本 (失效数量), 64 ＋ 65536, )

									临界.进入 ()

									按钮_开始停止.标题 ＝ “开始验证”

									按钮_开始停止.禁止 ＝ 假

									临界.退出 ()

									.子程序 验证子程序

									.参数 i, 整数型

									.局部变量 ip地址, 文本型

									.局部变量 端口, 文本型

									.局部变量 http, WinHttp

									.局部变量 str, 文本型

									.局部变量 time, 整数型

									.局部变量 timing, 整数型

									.局部变量 bool, 逻辑型

									.如果真 (线程池.取_状态 () ≠ #线程池_正在工作)

									  返回 ()

									.如果真结束

									临界.进入 ()

									ip地址 ＝ 列表_代理.取标题 (i, 1)

									端口 ＝ 列表_代理.取标题 (i, 2)

									临界.退出 ()

									.如果真 (ip地址 ＝ “” 或 端口 ＝ “”)

									  原子_递增 (已完成数量)

									  返回 ()

									.如果真结束

									time ＝ 取启动时间 ()

									http.SetProxy (2, ip地址 ＋ “:” ＋ 端口)

									http.SetTimeouts (连接超时, 连接超时, 验证超时, 验证超时)

									http.Open (“GET”, 验证网址, 真)

									http.Set_User_Agent ()

									http.Send ()

									timing ＝ 验证超时 ＼ 1000 ＋ 选择 (验证超时 ％ 1000 ＞ 0, 1, 0)

									.计次循环首 (timing, ) ' 这样写是为了能快速相应停止

									  bool ＝ http.WaitForResponse (1) ' 单位 秒

									  .如果真 (bool ＝ 真)

									    跳出循环 ()

									  .如果真结束

									  .如果真 (线程池.取_状态 () ≠ #线程池_正在工作) ' 当用户手动停止时 线程池状态就变了 这样就能触发返回了

									    http.Abort () ' 终止连接

									    原子_递增 (已完成数量)

									    返回 ()

									  .如果真结束

									.计次循环尾 ()

									time ＝ 取启动时间 () － time ' 算出超时

									.判断开始 (bool ＝ 真)

									  .判断开始 (是否UTF解码 ＝ 真)

									    str ＝ http.GetResponseTextUtf8 ()

									  .默认

									    str ＝ http.GetResponseText ()

									  .判断结束

									.默认

									  http.Abort ()

									.判断结束

									.判断开始 (str ＝ “”)

									  原子_递增 (失效数量)

									  设置表象 (i, “*/*”, 选择 (time ＞ 连接超时, “验证失败”, “连接超时”), 2)

									.判断 (寻找文本 (str, 验证字符串, , 假) ≠ -1)

									  原子_递增 (有效数量)

									  设置表象 (i, 到文本 (time), “验证成功”, 选择 (time ＜ 10000, 1, 3))

									.默认

									  原子_递增 (失效数量)

									  设置表象 (i, “*/*”, “验证失败”, 2)

									.判断结束

									原子_递增 (已完成数量)

									.子程序 设置表象

									.参数 index, 整数型

									.参数 time, 文本型

									.参数 stop, 文本型

									.参数 State, 整数型

									临界.进入 ()

									列表_代理.置标题 (index, 3, time)

									列表_代理.置标题 (index, 4, stop)

									列表_代理.置状态图片 (index, State)

									.如果真 (index ＞ 保证显示索引)

									  列表_代理.保证显示 (index ＋ 1)

									  保证显示索引 ＝ index ＋ 1

									.如果真结束

									临界.退出 ()

									.子程序 更新状态条

									临界.进入 ()

									状态条_状态.置文本 (1, “已完成验证：” ＋ 到文本 (已完成数量))

									状态条_状态.置文本 (2, “有效代理数：” ＋ 到文本 (有效数量))

									状态条_状态.置文本 (3, “失效代理数：” ＋ 到文本 (失效数量))

									临界.退出 ()

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

									线程池.销毁 ()

									' 防止用户意外点击红叉叉