Lua 内存泄漏检测与定位

-- 每次测量前强制完整回收，得到"存活对象"的真实占用
local function live_memory()
    collectgarbage("collect")        -- 完整 GC 一轮
    collectgarbage("collect")        -- 再走一轮，处理终结器产生的对象
    return collectgarbage("count")   -- 单位 KB
end

local base = live_memory()
print(string.format("基线: %.1f KB", base))

-- 模拟业务循环
for round = 1, 100 do
    do_work()                        -- 待测的业务函数
    if round % 10 == 0 then
        local now = live_memory()
        print(string.format("第 %d 轮: %.1f KB (增量 %.1f)", round, now, now - base))
    end
end

-- 登记所有创建出来的对象，但用弱引用持有，不阻止回收
local tracked = setmetatable({}, {__mode = "v"})

local function make_entity(id)
    local e = {id = id, hp = 100}
    tracked[id] = e          -- 弱引用登记
    return e
end

-- 业务上认为实体已经销毁后：
local leaked = 0
for id, e in pairs(tracked) do
    if e ~= nil then         -- 条目还在，说明对象没被回收
        leaked = leaked + 1
    end
end
print("疑似未回收对象:", leaked)

-- 用 debug 库遍历堆上的所有对象并归类计数（Lua 5.4 / 5.3 支持）
local function snapshot()
    local count = {}
    local function walk(o, depth)
        if depth > 4 then return end          -- 限制深度，避免遍历过深
        local t = type(o)
        count[t] = (count[t] or 0) + 1
        if t == "table" then
            for k, v in pairs(o) do
                walk(k, depth + 1)
                walk(v, depth + 1)
            end
        end
    end
    -- 从注册表遍历可达对象
    walk(debug.getregistry(), 0)
    return count
end

local before = snapshot()
run_suspect_code()
local after = snapshot()

for kind, n in pairs(after) do
    local delta = n - (before[kind] or 0)
    if delta > 0 then
        print(string.format("%s: +%d", kind, delta))
    end
end

-- 错误：用全局表当缓存，只增不减
function cache_user(user)
    temp_cache = temp_cache or {}
    temp_cache[user.id] = user
end

-- 修复：改为局部 + 有上限的结构
local cache = {}
local MAX = 1000
function cache_user(user)
    if next(cache) == nil then cache = {} end
    cache[user.id] = user
    -- 或用 LRU 淘汰
end

setmetatable(_G, {
    __newindex = function(_, k, v)
        print("全局赋值:", k, debug.traceback("", 2))
        rawset(_G, k, v)
    end
})

-- 错误：闭包捕获了整个 config，导致 config 无法回收
local config = load_big_config()
local function handler(req)
    return process(req, config.name)   -- 只用了一个字段，却持有了整个 config
end

-- 修复：只捕获需要的值
local name = config.name
local function handler(req)
    return process(req, name)
end
config = nil   -- 现在可以回收了

for i = 1, math.huge do
    local name, val = debug.getupvalue(handler, i)
    if not name then break end
    print(i, name, type(val))
end

local listeners = {}

function on(event, cb)
    listeners[event] = listeners[event] or {}
    table.insert(listeners[event], cb)
end

function off(event, cb)
    local list = listeners[event]
    if not list then return end
    for i = #list, 1, -1 do
        if list[i] == cb then table.remove(list, i) end
    end
end

-- 对象销毁时必须调用 off，否则泄漏
function destroy(obj)
    off("update", obj.on_update)   -- 关键：显式注销
    obj.on_update = nil
end

-- 方案 A：弱值表，对象在别处无引用时自动清理
local cache = setmetatable({}, {__mode = "v"})

-- 方案 B：容量受限的 LRU（保留最近 N 个）
local LRU = {}
LRU.__index = LRU
function LRU.new(max)
    return setmetatable({max = max, n = 0, map = {}}, LRU)
end
function LRU:get(k)
    local node = self.map[k]
    if not node then return nil end
    -- 移动到队首（此处省略链表细节）
    return node.value
end

-- 定时采样，超过阈值时告警并 dump 关键表的规模
local function monitor()
    local now = collectgarbage("count")
    if now > MEM_THRESHOLD_KB then
        log_warn("内存超阈值: %.1f KB", now)
        for name, t in pairs(WATCHED_TABLES) do
            local n = 0
            for _ in pairs(t) do n = n + 1 end
            log_warn("表 %s 条目数: %d", name, n)
        end
    end
end