内存剖析与 dump 分析

# 快速判断是否泄漏：连续观察 GC 后的存活堆
dotnet-counters monitor \
  --process-id 12345 \
  --counters System.Runtime
# 关注 gc-heap-size、gen-2-size、alloc-rate 三条曲线

# 安装诊断工具（全局工具，装在排查机上）
dotnet tool install --global dotnet-dump
dotnet tool install --global dotnet-gcdump
dotnet tool install --global dotnet-counters
dotnet tool install --global dotnet-trace

# 采集完整 dump：用于分析对象字段、调用栈、线程状态
dotnet-dump collect --process-id 12345 --type Full --output /tmp/app.dump

# 采集 gcdump：只含托管堆的对象图，体积小，适合对比
dotnet-gcdump collect --process-id 12345 --output /tmp/app.gcdump

# 分析 gcdump（跨平台，可在开发机上打开）
dotnet-gcdump report /tmp/app.gcdump

// 进程内触发采集：配合健康检查端点，在内存超阈值时自动抓取
public sealed class DumpEndpoint
{
    public static void Map(WebApplication app)
    {
        app.MapPost("/diag/dump", async (IHostEnvironment env) =>
        {
            if (!env.IsDevelopment() && !env.IsStaging())
                return Results.NotFound();

            var path = $"/tmp/app-{DateTimeOffset.UtcNow:yyyyMMddHHmmss}.dump";
            // 生产环境应通过 dotnet-dump 外部采集，避免进程内暂停
            return Results.Ok(new { path });
        });
    }
}

# 加载 dump 并进入 SOS 分析会话
dotnet-dump analyze /tmp/app.dump

# 会话内：先看托管堆总体情况
> eeheap -gc          # 各代堆大小与地址范围
> clrthreads          # 所有托管线程与状态
> dumpheap -stat      # 按类型统计对象数与总大小（关键命令）

# 典型输出（截取）：
#   MT        Count    TotalSize  Class Name
# 00007f...     18234    312456789  System.Byte[]
# 00007f...    892341     42832368  System.String
# 00007f...      4211     18432000  Contoso.Cache.Entry

# 从统计到实例：找到大对象的具体地址
> dumpheap -mt 00007f9a1c002a30 -min 85000    # 只列大对象
> dumpobj 000001d4a2b3c4d0                    # 查看单个对象内容
> dumpvc 000001d4a2b3c4d0 00007f9a1c002a30    # 查看值类型字段
> objsize 000001d4a2b3c4d0                    # 单个对象占用字节数
> gcroot 000001d4a2b3c4d0                     # 谁持有这个对象（关键）

# 线程栈：看是否有线程卡住导致对象长期存活
> clrstack -all            # 所有线程的托管调用栈
> clrstack -p 00007f9a...  # 带参数值
> syncblk                  # 锁竞争与阻塞情况
> dumpasync                # 异步状态机与未完成的任务

# 完整流程：从可疑类型到引用链
> dumpheap -stat                                    # 1. 找可疑类型
#   MT        Count   TotalSize  Class Name
# 00007f...     48210    98765432  Contoso.Cache.CachedProduct
> dumpheap -mt 00007f9a1c004100 -min 1000           # 2. 列出实例
> gcroot 000001d4a2b3c4d0                           # 3. 追引用链

# 典型输出：
#   Found 1 unique root(s).
#   Thread 12:
#     00007ff...  Contoso.Cache.ProductCache  <- 静态字段
#        _items (System.Collections.Generic.Dictionary`2)
#          [1024] (Contoso.Cache.CachedProduct)
#   ...
#   结论：静态字典无上限增长，且没有过期淘汰

// 对应的问题代码：静态字典只增不减
public sealed class ProductCache
{
    // 静态字段是 GC 根：只要进程活着，字典里的对象永远不会被回收
    private static readonly Dictionary<int, CachedProduct> _items = new();

    public CachedProduct GetOrAdd(int id, Func<int, CachedProduct> factory)
    {
        if (!_items.TryGetValue(id, out var item))
        {
            item = factory(id);
            _items[id] = item;      // 没有上限，没有过期
        }
        return item;
    }
}

// 模式一：事件订阅未退订——发布者（长寿）持有订阅者（短寿）
public sealed class OrderPublisher
{
    public event EventHandler<OrderEventArgs>? OrderPlaced;
    public void Raise(Order order) => OrderPlaced?.Invoke(this, new(order));
}

// 错误：每次创建 Page 都订阅，但从不退订
public sealed class Page
{
    public Page(OrderPublisher pub) => pub.OrderPlaced += OnOrderPlaced;
    private void OnOrderPlaced(object? s, OrderEventArgs e) { }
    // 缺少：public void Dispose() => _pub.OrderPlaced -= OnOrderPlaced;
}

// 模式二：静态集合累积——无上限的 List/Dictionary 作为全局状态
public static class AuditLog
{
    private static readonly List<string> _entries = new();   // 只增不减
    public static void Add(string entry) => _entries.Add(entry);
}

// 模式三：IDisposable 未释放——HttpClient、Stream、DbContext
public Stream ReadFile(string path) => File.OpenRead(path);   // 调用方忘了 using

// 模式四：Timer 未释放——回调持有目标对象
_timer = new Timer(OnTick, state, TimeSpan.Zero, TimeSpan.FromSeconds(1));
// 缺少：_timer.Dispose()，且 Timer 自身会被运行时根引用

// 模式五：异步任务悬挂——未 await 的 Task 保留整个状态机
public void FireAndForget() => DoWorkAsync();   // 异常被吞，状态机长期存活

# 检查 LOH 与碎片：Free 对象占比高说明碎片严重
> eeheap -gc
# 输出中关注：
#   generation 2 starts at ... size ...
#   Large object heap starts at ... size ...
#   Total Size: ...
> dumpheap -stat | grep Free
# 大量 Free 对象 + 总空闲很大但仍 OOM = 碎片问题

# 手动触发压缩式 GC（临时缓解，不解决根因）
> gchandles
> dumpheap -stat -min 85000

<!-- 开启 LOH 压缩：牺牲部分 GC 时间换内存连续性 -->
<configuration>
  <runtime>
    <GCLargePages enabled="false" />
    <GCHeapHardLimitPercent>0.75</GCHeapHardLimitPercent>
  </runtime>
</configuration>

// 应用层解法：用 ArrayPool 复用大数组，避免反复分配进入 LOH
public async Task<byte[]> ReadPayloadAsync(Stream source, CancellationToken ct)
{
    var buffer = ArrayPool<byte>.Shared.Rent(128 * 1024);   // 池化，不进 LOH
    try
    {
        var read = await source.ReadAsync(buffer.AsMemory(0, 128 * 1024), ct);
        return buffer[..read].ToArray();   // 只在必须时复制
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

# 标准四步流程
# 第一步：确认趋势（实时指标）
dotnet-counters monitor -p 12345 --counters System.Runtime

# 第二步：采集两份快照，间隔一段时间或一个操作周期
dotnet-gcdump collect -p 12345 -o /tmp/before.gcdump
# ...等待 5 分钟或执行一次可疑操作...
dotnet-gcdump collect -p 12345 -o /tmp/after.gcdump

# 第三步：对比两份报告，找出增长最快的类型
dotnet-gcdump report /tmp/before.gcdump > before.txt
dotnet-gcdump report /tmp/after.gcdump  > after.txt
diff before.txt after.txt | head -50

# 第四步：对增长类型追引用链，定位持有者
dotnet-dump collect -p 12345 -o /tmp/full.dump
dotnet-dump analyze /tmp/full.dump -c "dumpheap -stat" -c "exit"

// 自动采集：内存超阈值时抓 gcdump，并限制采集频率避免雪崩
public sealed class MemoryGuard(
    IOptions<MemoryGuardOptions> options,
    ILogger<MemoryGuard> logger) : BackgroundService
{
    private DateTimeOffset _lastCapture = DateTimeOffset.MinValue;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        using var timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
        while (await timer.WaitForNextTickAsync(ct))
        {
            var info = GC.GetGCMemoryInfo();
            var usedRatio = (double)info.HeapSizeBytes / info.TotalAvailableMemoryBytes;

            if (usedRatio < options.Value.ThresholdRatio) continue;
            if (DateTimeOffset.UtcNow - _lastCapture < options.Value.MinInterval) continue;

            _lastCapture = DateTimeOffset.UtcNow;
            logger.LogWarning("内存使用率 {Ratio:P0}，触发快照采集", usedRatio);
            // 通过 sidecar 或 dotnet-gcdump 外部触发，避免进程内暂停
        }
    }
}