易语言内存泄漏追踪：句柄管理的隐形陷阱

一、句柄泄漏的典型症状分析

1. 程序内存持续增长模式

.版本 2
.程序集 内存监控程序集
.子程序 监控内存变化

.局部变量 初始内存, 整数型
.局部变量 当前内存, 整数型
.局部变量 增长次数, 整数型

初始内存 ＝ 取程序内存使用量 ()
.计次循环首 (100, )
    执行可能泄漏的操作 ()
    当前内存 ＝ 取程序内存使用量 ()
    
    .如果 (当前内存 － 初始内存 ＞ 10 × 1024 × 1024)  ' 增长超过10MB
        增长次数 ＝ 增长次数 ＋ 1
        标准输出 (“警告：内存异常增长 ” ＋ 到文本 (增长次数) ＋ “ 次” ＋ #换行符)
    .如果结束
    
    延时 (1000)
.计次循环尾

2. 句柄泄漏检测工具

.版本 2
.程序集 句柄检测工具
.子程序 获取系统句柄信息, 整数型
.参数 进程ID, 整数型, 可空

.局部变量 系统信息, 系统信息类型
.局部变量 句柄数量, 整数型

.如果 (是否为空 (进程ID))
    进程ID ＝ 取进程ID ()
.如果结束

' 调用系统API获取句柄信息
句柄数量 ＝ GetGuiResources (进程ID, 0)  ' 获取GDI句柄数
标准输出 (“GDI句柄数: ” ＋ 到文本 (句柄数量) ＋ #换行符)

句柄数量 ＝ GetGuiResources (进程ID, 1)  ' 获取用户句柄数  
标准输出 (“用户句柄数: ” ＋ 到文本 (句柄数量) ＋ #换行符)

返回 (句柄数量)

.DLL命令 GetGuiResources, 整数型, "user32.dll", "GetGuiResources"
    .参数 hProcess, 整数型
    .参数 uiFlags, 整数型

二、窗口句柄泄漏解决方案

1. 窗口创建与销毁的完整生命周期

.版本 2
.程序集 窗口句柄管理
.全局变量 窗口句柄数组, 整数型, , "0"
.全局变量 最大窗口数, 整数型

.子程序 创建受管窗口, 整数型
.参数 父窗口, 整数型, 可空

.局部变量 窗口句柄, 整数型
.局部变量 窗口信息, 窗口信息类型

.如果 (取数组成员数 (窗口句柄数组) ≥ 最大窗口数)
    标准输出 (“错误：达到最大窗口限制” ＋ #换行符)
    返回 (0)
.如果结束

窗口句柄 ＝ 创建窗口 (“窗口类名”, “窗口标题”, 父窗口)
.如果真 (窗口句柄 ≠ 0)
    加入成员 (窗口句柄数组, 窗口句柄)
    标准输出 (“创建窗口句柄: ” ＋ 到文本 (窗口句柄) ＋ “, 当前总数: ” ＋ 到文本 (取数组成员数 (窗口句柄数组)) ＋ #换行符)
.如果真结束

返回 (窗口句柄)

.子程序 销毁受管窗口, 逻辑型
.参数 窗口句柄, 整数型

.局部变量 索引, 整数型

索引 ＝ 查找数组成员 (窗口句柄数组, 窗口句柄)
.如果真 (索引 ＝ -1)
    标准输出 (“警告：尝试销毁未管理的窗口句柄” ＋ #换行符)
    返回 (假)
.如果真结束

.如果真 (销毁窗口 (窗口句柄))
    删除成员 (窗口句柄数组, 索引, 1)
    标准输出 (“销毁窗口句柄: ” ＋ 到文本 (窗口句柄) ＋ “, 剩余总数: ” ＋ 到文本 (取数组成员数 (窗口句柄数组)) ＋ #换行符)
    返回 (真)
.如果真结束

返回 (假)

2. 自动化窗口泄漏检测

.版本 2
.子程序 检测窗口泄漏
.局部变量 预期窗口数, 整数型
.局部变量 实际窗口数, 整数型

预期窗口数 ＝ 1  ' 主窗口
实际窗口数 ＝ 取数组成员数 (窗口句柄数组)

.如果 (实际窗口数 ≠ 预期窗口数)
    标准输出 (“窗口泄漏检测: 预期 ” ＋ 到文本 (预期窗口数) ＋ “ 个, 实际 ” ＋ 到文本 (实际窗口数) ＋ “ 个” ＋ #换行符)
    .如果 (实际窗口数 ＞ 预期窗口数)
        清理泄漏窗口 ()
    .如果结束
.如果结束

三、GDI对象泄漏根治方案

1. 画笔画刷资源管理

.版本 2
.程序集 GDI资源管理
.全局变量 画笔句柄数组, 整数型, , "0"
.全局变量 画刷句柄数组, 整数型, , "0"
.全局变量 字体句柄数组, 整数型, , "0"

.子程序 创建受管画笔, 整数型
.参数 颜色, 整数型
.参数 宽度, 整数型, 可空

.局部变量 画笔句柄, 整数型

.如果 (是否为空 (宽度))
    画笔句柄 ＝ 创建画笔 (颜色)
.否则
    画笔句柄 ＝ 创建画笔_扩展 (颜色, 宽度)
.如果结束

.如果真 (画笔句柄 ≠ 0)
    加入成员 (画笔句柄数组, 画笔句柄)
.如果真结束

返回 (画笔句柄)

.子程序 释放所有GDI资源
.局部变量 索引, 整数型

' 释放所有画笔
.计次循环首 (取数组成员数 (画笔句柄数组), 索引)
    删除对象 (画笔句柄数组 [索引])
.计次循环尾
清除数组 (画笔句柄数组)

' 释放所有画刷
.计次循环首 (取数组成员数 (画刷句柄数组), 索引)
    删除对象 (画刷句柄数组 [索引])
.计次循环尾
清除数组 (画刷句柄数组)

' 释放所有字体
.计次循环首 (取数组成员数 (字体句柄数组), 索引)
    删除对象 (字体句柄数组 [索引])
.计次循环尾
清除数组 (字体句柄数组)

标准输出 (“已释放所有GDI资源” ＋ #换行符)

2. 内存DC泄漏防护

.版本 2
.子程序 安全内存DC操作
.参数 目标DC, 整数型

.局部变量 内存DC, 整数型
.局部变量 位图句柄, 整数型
.局部变量 旧位图句柄, 整数型

内存DC ＝ 创建兼容DC (目标DC)
位图句柄 ＝ 创建兼容位图 (目标DC, 800, 600)
旧位图句柄 ＝ 选择对象 (内存DC, 位图句柄)

尝试
    ' 在内存DC上进行绘图操作
    执行绘图操作 (内存DC)
捕获
    标准输出 (“绘图操作异常” ＋ #换行符)
结束尝试

' 确保资源释放
选择对象 (内存DC, 旧位图句柄)  ' 恢复旧位图
删除对象 (位图句柄)          ' 删除创建的位图
删除DC (内存DC)              ' 删除内存DC

.子程序 执行绘图操作
.参数 DC句柄, 整数型
' 具体的绘图代码
矩形 (DC句柄, 0, 0, 800, 600)

四、文件句柄泄漏监控

1. 文件操作封装类

.版本 2
.程序集 安全文件操作
.全局变量 打开文件列表, 文本型, , "0"  ' 存储打开的文件路径

.子程序 安全打开文件, 整数型
.参数 文件路径, 文本型
.参数 打开方式, 整数型, 可空

.局部变量 文件号, 整数型

.如果 (是否为空 (打开方式))
    文件号 ＝ 打开文件 (文件路径, , )
.否则
    文件号 ＝ 打开文件 (文件路径, 打开方式, )
.如果结束

.如果真 (文件号 ≠ 0)
    加入成员 (打开文件列表, 文件路径)
    标准输出 (“打开文件: ” ＋ 文件路径 ＋ “, 文件号: ” ＋ 到文本 (文件号) ＋ #换行符)
.如果真结束

返回 (文件号)

.子程序 安全关闭文件, 逻辑型
.参数 文件号, 整数型
.参数 文件路径, 文本型

.局部变量 索引, 整数型

索引 ＝ 查找数组成员 (打开文件列表, 文件路径)
.如果真 (索引 ≠ -1)
    删除成员 (打开文件列表, 索引, 1)
.如果真结束

.如果真 (关闭文件 (文件号))
    标准输出 (“关闭文件: ” ＋ 文件路径 ＋ #换行符)
    返回 (真)
.如果真结束

返回 (假)

.子程序 强制关闭所有文件
.局部变量 索引, 整数型

.计次循环首 (取数组成员数 (打开文件列表), 索引)
    标准输出 (“警告: 未关闭文件: ” ＋ 打开文件列表 [索引] ＋ #换行符)
.计次循环尾

清除数组 (打开文件列表)
标准输出 (“已强制清理文件句柄” ＋ #换行符)

五、综合泄漏检测系统

1. 实时监控框架

.版本 2
.程序集 内存泄漏监控系统
.全局变量 监控线程句柄, 整数型
.全局变量 监控状态, 逻辑型

.子程序 启动泄漏监控
监控状态 ＝ 真
监控线程句柄 ＝ 启动线程 (&监控循环, , )

.子程序 监控循环
.局部变量 初始句柄数, 整数型
.局部变量 当前句柄数, 整数型

初始句柄数 ＝ 获取系统句柄信息 (取进程ID ())

.判断循环首 (监控状态)
    延时 (5000)  ' 每5秒检测一次
    
    当前句柄数 ＝ 获取系统句柄信息 (取进程ID ())
    
    .如果 (当前句柄数 － 初始句柄数 ＞ 50)
        标准输出 (“严重：检测到句柄泄漏，增长 ” ＋ 到文本 (当前句柄数 － 初始句柄数) ＋ “ 个” ＋ #换行符)
        生成泄漏报告 ()
    .否则
        .如果 (当前句柄数 － 初始句柄数 ＞ 10)
            标准输出 (“警告：句柄缓慢增长，当前 ” ＋ 到文本 (当前句柄数 － 初始句柄数) ＋ “ 个” ＋ #换行符)
        .如果结束
    .如果结束
.判断循环尾

.子程序 生成泄漏报告
.局部变量 报告内容, 文本型

报告内容 ＝ “内存泄漏检测报告” ＋ #换行符
报告内容 ＝ 报告内容 ＋ “生成时间: ” ＋ 时间_到文本 (取现行时间 (), ) ＋ #换行符
报告内容 ＝ 报告内容 ＋ “当前进程ID: ” ＋ 到文本 (取进程ID ()) ＋ #换行符
报告内容 ＝ 报告内容 ＋ “GDI句柄数: ” ＋ 到文本 (GetGuiResources (取进程ID (), 0)) ＋ #换行符
报告内容 ＝ 报告内容 ＋ “用户句柄数: ” ＋ 到文本 (GetGuiResources (取进程ID (), 1)) ＋ #换行符
报告内容 ＝ 报告内容 ＋ “打开文件数: ” ＋ 到文本 (取数组成员数 (打开文件列表)) ＋ #换行符

写到文件 (“泄漏报告_” ＋ 时间_到文本 (取现行时间 (), 1) ＋ “.txt”, 到字节集 (报告内容))

总结

易语言内存泄漏问题主要源于句柄资源未正确释放。通过建立完整的资源管理体系，实时监控句柄数量变化，可以及早发现并修复泄漏问题。

关键防护措施：

1. 所有句柄创建必须有对应的释放机制
2. 使用封装类管理GDI对象生命周期
3. 文件操作确保在异常情况下也能正确关闭
4. 建立实时监控系统及时发现泄漏趋势

建议在程序关键节点插入泄漏检测代码，在开发阶段就发现潜在的内存问题，避免在用户环境中出现程序运行时间越长性能越差的情况。