内存优化与对象池化

概述

EF Core 应用在高并发场景下面临的主要挑战之一是内存使用效率。不当的内存管理会导致 GC 压力增大、响应时间波动、甚至 OutOfMemoryException。本章节深入讲解 EF Core 相关的内存优化技术和对象池化策略。

核心问题

问题	说明	影响
频繁分配	每次请求创建大量临时对象	GC 压力大
DbContext 泄漏	未正确释放 DbContext 实例	内存持续增长
ChangeTracker 膨胀	跟踪过多实体,内存占用高	性能下降
大对象分配	一次性加载大量数据	LOH 碎片化
连接池耗尽	数据库连接未及时释放	请求阻塞

优化目标

• ✅ 减少内存分配次数
• ✅ 降低 GC 频率
• ✅ 避免内存泄漏
• ✅ 提高对象复用率
• ✅ 优化大对象处理

---

ChangeTracker 优化

问题: ChangeTracker 内存膨胀

// ❌ 错误: 长时间持有 DbContext,ChangeTracker 累积实体
public class BadService
{
    private readonly AppDbContext _context;
    
    public BadService(AppDbContext context)
    {
        _context = context;  // ⚠️ 长期持有
    }
    
    public async Task ProcessManyItemsAsync()
    {
        for (int i = 0; i < 10000; i++)
        {
            var item = new Item { Name = $"Item {i}" };
            _context.Items.Add(item);
            
            if (i % 100 == 0)
            {
                await _context.SaveChangesAsync();
                // ⚠️ ChangeTracker 仍然跟踪所有实体!
            }
        }
    }
}

解决方案 1: 及时清理 ChangeTracker

// ✅ 正确: 定期清理 ChangeTracker
public async Task ProcessManyItemsAsync()
{
    using var context = _factory.CreateDbContext();
    
    for (int i = 0; i < 10000; i++)
    {
        var item = new Item { Name = $"Item {i}" };
        context.Items.Add(item);
        
        if (i % 100 == 0)
        {
            await context.SaveChangesAsync();
            
            // ✅ 清理 ChangeTracker,释放内存
            context.ChangeTracker.Clear();
        }
    }
}

解决方案 2: 批量处理

// ✅ 推荐: 分批处理,每批使用独立的 DbContext
public async Task ProcessManyItemsAsync()
{
    const int batchSize = 100;
    var totalItems = 10000;
    
    for (int batch = 0; batch < totalItems / batchSize; batch++)
    {
        // 每批使用新的 DbContext
        using var context = _factory.CreateDbContext();
        
        var items = Enumerable.Range(batch * batchSize, batchSize)
            .Select(i => new Item { Name = $"Item {i}" })
            .ToList();
        
        context.Items.AddRange(items);
        await context.SaveChangesAsync();
        
        // using 结束时自动释放,ChangeTracker 清空
    }
}

监控 ChangeTracker 大小

// ChangeTrackerMonitor.cs
public class ChangeTrackerMonitor
{
    private readonly ILogger<ChangeTrackerMonitor> _logger;

    public ChangeTrackerMonitor(ILogger<ChangeTrackerMonitor> logger)
    {
        _logger = logger;
    }

    public void Monitor(DbContext context, string operation)
    {
        var trackedEntities = context.ChangeTracker.Entries().Count();
        
        if (trackedEntities > 1000)
        {
            _logger.LogWarning("""
                Large ChangeTracker detected!
                Operation: {Operation}
                Tracked Entities: {Count}
                Consider calling ChangeTracker.Clear()
                """,
                operation,
                trackedEntities);
        }
    }
}

// 使用
public async Task SaveChangesWithMonitoring(AppDbContext context)
{
    _monitor.Monitor(context, "BeforeSave");
    await context.SaveChangesAsync();
}

---

AsNoTracking 深度优化

基础用法回顾

// ✅ 只读查询使用 AsNoTracking
var products = await context.Products
    .AsNoTracking()
    .Where(p => p.Price > 100)
    .ToListAsync();

AsNoTrackingWithIdentityResolution

// EF Core 5+ 新特性
// 场景: 需要引用相等性,但不需要变更跟踪

var orders = await context.Orders
    .AsNoTrackingWithIdentityResolution()  // ← 关键
    .Include(o => o.Customer)
    .ToListAsync();

// 优势:
// - 同一实体的多次引用指向同一对象(引用相等)
// - 不进行变更跟踪(节省内存)
// - 适合复杂对象图

// 对比:
var order1 = orders.First();
var order2 = orders.First();

// AsNoTracking(): order1 != order2 (不同实例)
// AsNoTrackingWithIdentityResolution(): order1 == order2 (相同实例)

全局配置

// Program.cs
builder.Services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(connectionString);
    
    // ✅ 全局默认无跟踪(适合读多写少的应用)
    options.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
});

// 需要跟踪时显式指定
var product = await context.Products
    .AsTracking()  // 覆盖全局配置
    .FirstOrDefaultAsync(p => p.Id == id);

---

对象池化

DbContext 池化

// Program.cs
builder.Services.AddDbContextPool<AppDbContext>(
    options => options.UseSqlServer(connectionString),
    poolSize: 128  // 池大小,默认 128
);

// 性能提升:
// - 减少 DbContext 创建开销 (~30%)
// - 降低 GC 压力
// - 提高吞吐量 (~50%)

// 适用场景:
// ✅ Web 应用(高并发)
// ✅ 短期操作
// ❌ 长期运行的任务
// ❌ Blazor Server(使用工厂)

工作原理

未使用池化:
请求 → 创建 DbContext → 使用 → 销毁(GC)
       ↑ 每次都有创建/销毁开销

使用池化:
首次: 请求 → 创建 DbContext → 使用 → 归还池中
后续: 请求 → 从池获取(重置状态) → 使用 → 归还池中
       ↑ 复用实例,避免创建/销毁

配置池大小

// 根据并发量调整
int CalculateOptimalPoolSize()
{
    var processorCount = Environment.ProcessorCount;
    var expectedConcurrentRequests = 100; // 预估并发请求数
    
    // 经验公式: CPU核心数 * 并发请求数 / 2
    // 最小 16,最大 256
    return Math.Min(256, Math.Max(16, 
        processorCount * expectedConcurrentRequests / 2));
}

builder.Services.AddDbContextPool<AppDbContext>(
    options => options.UseSqlServer(connectionString),
    poolSize: CalculateOptimalPoolSize());

监控池性能

// DbContextPoolMetrics.cs
public class DbContextPoolMetrics
{
    private readonly ILogger<DbContextPoolMetrics> _logger;
    private int _hitCount = 0;
    private int _missCount = 0;

    public DbContextPoolMetrics(ILogger<DbContextPoolMetrics> logger)
    {
        _logger = logger;
    }

    public void RecordHit()
    {
        Interlocked.Increment(ref _hitCount);
    }

    public void RecordMiss()
    {
        Interlocked.Increment(ref _missCount);
    }

    public void ReportMetrics()
    {
        var total = _hitCount + _missCount;
        var hitRate = total > 0 ? (double)_hitCount / total * 100 : 0;
        
        _logger.LogInformation("""
            DbContext Pool Metrics:
            Hits: {Hits}
            Misses: {Misses}
            Hit Rate: {HitRate:F2}%
            """,
            _hitCount,
            _missCount,
            hitRate);
    }
}

---

ArrayPool 和 MemoryPool

减少数组分配

// ❌ 错误: 频繁分配数组
public byte[] ProcessData(byte[] input)
{
    var buffer = new byte[input.Length];  // ⚠️ 每次分配新数组
    // 处理数据...
    return buffer;
}

// ✅ 正确: 使用 ArrayPool
public byte[] ProcessData(byte[] input)
{
    // 从池中租用数组
    var buffer = ArrayPool<byte>.Shared.Rent(input.Length);
    
    try
    {
        // 处理数据
        Array.Copy(input, buffer, input.Length);
        // ...
        
        var result = new byte[input.Length];
        Array.Copy(buffer, result, input.Length);
        return result;
    }
    finally
    {
        // ✅ 归还到池中
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

MemoryPool 用于 Span/Memory

// ✅ 使用 MemoryPool<T>
public void ProcessLargeDataset()
{
    using var memoryOwner = MemoryPool<int>.Shared.Rent(10000);
    var memory = memoryOwner.Memory.Slice(0, 10000);
    
    // 使用 Span 处理,零分配
    var span = memory.Span;
    for (int i = 0; i < span.Length; i++)
    {
        span[i] = i * 2;
    }
}

EF Core 中的应用

// 批量读取二进制数据
public async Task<List<byte[]>> ReadBinaryDataAsync(List<int> ids)
{
    var results = new List<byte[]>();
    
    // 租用缓冲区
    var buffer = ArrayPool<byte>.Shared.Rent(1024 * 1024); // 1MB
    
    try
    {
        foreach (var id in ids)
        {
            var data = await context.Documents
                .Where(d => d.Id == id)
                .Select(d => d.Content)
                .FirstOrDefaultAsync();
            
            if (data != null && data.Length <= buffer.Length)
            {
                Array.Copy(data, buffer, data.Length);
                results.Add(buffer.Take(data.Length).ToArray());
            }
        }
    }
    finally
    {
        ArrayPool<byte>.Shared.Return(buffer);
    }
    
    return results;
}

---

流式处理大数据集

问题: 一次性加载大量数据

// ❌ 错误: 加载 100 万条记录到内存
var allRecords = await context.Records.ToListAsync();
// ⚠️ 内存占用可能超过 1GB

解决方案 1: AsAsyncEnumerable 流式处理

// ✅ 推荐: 流式处理,逐条读取
await foreach (var record in context.Records
    .AsNoTracking()
    .AsAsyncEnumerable())
{
    ProcessRecord(record);  // 逐个处理,不全部加载到内存
    
    // 可选: 定期报告进度
    if (++count % 1000 == 0)
    {
        _logger.LogInformation("Processed {Count} records", count);
    }
}

解决方案 2: 分页处理

// ✅ 分页加载
const int pageSize = 1000;
int page = 0;

while (true)
{
    var records = await context.Records
        .AsNoTracking()
        .OrderBy(r => r.Id)
        .Skip(page * pageSize)
        .Take(pageSize)
        .ToListAsync();
    
    if (records.Count == 0)
        break;
    
    foreach (var record in records)
    {
        ProcessRecord(record);
    }
    
    page++;
    
    // 可选: 定期清理内存
    if (page % 10 == 0)
    {
        GC.Collect();  // 谨慎使用
    }
}

解决方案 3: 后台任务分块

// BackgroundService 中处理
protected override async Task ExecuteAsync(CancellationToken ct)
{
    var lastProcessedId = 0;
    const int batchSize = 500;
    
    while (!ct.IsCancellationRequested)
    {
        using var scope = _serviceProvider.CreateScope();
        var context = scope.ServiceProvider.GetRequiredService<AppDbContext>();
        
        var records = await context.Records
            .AsNoTracking()
            .Where(r => r.Id > lastProcessedId)
            .OrderBy(r => r.Id)
            .Take(batchSize)
            .ToListAsync(ct);
        
        if (records.Count == 0)
            break;
        
        foreach (var record in records)
        {
            await ProcessRecordAsync(record, ct);
            lastProcessedId = record.Id;
        }
        
        // 批次间短暂暂停,让 GC 有机会回收
        await Task.Delay(100, ct);
    }
}

---

缓存优化

内存缓存

// 缓存频繁访问的数据
public class CachedProductService
{
    private readonly IMemoryCache _cache;
    private readonly IDbContextFactory<AppDbContext> _factory;
    private readonly TimeSpan _cacheDuration = TimeSpan.FromMinutes(30);

    public async Task<Product?> GetProductAsync(int id)
    {
        var cacheKey = $"product:{id}";
        
        return await _cache.GetOrCreateAsync(cacheKey, async entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = _cacheDuration;
            entry.Size = 1;  // 用于缓存大小限制
            
            using var context = _factory.CreateDbContext();
            return await context.Products
                .AsNoTracking()
                .FirstOrDefaultAsync(p => p.Id == id);
        });
    }
}

// 配置缓存大小限制
builder.Services.AddMemoryCache(options =>
{
    options.SizeLimit = 1024;  // 最多缓存 1024 个单位
});

分布式缓存(Redis)

// 适用于多实例部署
public class DistributedProductService
{
    private readonly IDistributedCache _cache;
    private readonly IDbContextFactory<AppDbContext> _factory;

    public async Task<Product?> GetProductAsync(int id)
    {
        var cacheKey = $"product:{id}";
        var cached = await _cache.GetStringAsync(cacheKey);
        
        if (cached != null)
        {
            return JsonSerializer.Deserialize<Product>(cached);
        }
        
        using var context = _factory.CreateDbContext();
        var product = await context.Products
            .AsNoTracking()
            .FirstOrDefaultAsync(p => p.Id == id);
        
        if (product != null)
        {
            var json = JsonSerializer.Serialize(product);
            await _cache.SetStringAsync(cacheKey, json, 
                new DistributedCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1),
                    SlidingExpiration = TimeSpan.FromMinutes(10)
                });
        }
        
        return product;
    }
}

---

大对象优化

避免 LOH (Large Object Heap) 碎片化

// ❌ 错误: 频繁分配大对象 (>85KB)
public byte[] ReadLargeFile(string path)
{
    return File.ReadAllBytes(path);  // ⚠️ 直接进入 LOH
}

// ✅ 正确: 使用流式读取
public async Task ProcessLargeFileAsync(string path)
{
    await using var stream = File.OpenRead(path);
    var buffer = new byte[8192];  // 8KB,在 SOH 中
    
    int bytesRead;
    while ((bytesRead = await stream.ReadAsync(buffer)) > 0)
    {
        ProcessChunk(buffer.AsSpan(0, bytesRead));
    }
}

EF Core 中的大字段处理

// ❌ 错误: 加载包含大字段的实体
var documents = await context.Documents.ToListAsync();
// ⚠️ 如果 Document.Content 是大文本/BLOB,内存占用巨大

// ✅ 正确: 投影查询,仅加载需要的字段
var documentSummaries = await context.Documents
    .AsNoTracking()
    .Select(d => new DocumentSummary
    {
        Id = d.Id,
        Title = d.Title,
        ContentLength = d.Content.Length  // 仅加载长度
    })
    .ToListAsync();

// 需要完整内容时单独加载
var content = await context.Documents
    .Where(d => d.Id == docId)
    .Select(d => d.Content)
    .FirstOrDefaultAsync();

---

连接池优化

配置连接池

// 连接字符串中配置
var connectionString = @"
    Server=localhost;
    Database=MyApp;
    Trusted_Connection=True;
    Min Pool Size=5;      -- 最小连接数
    Max Pool Size=100;    -- 最大连接数
    Connection Lifetime=300;  -- 连接最大生存期(秒)
    Connect Timeout=15;   -- 连接超时(秒)
";

builder.Services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString));

监控连接池

// ConnectionPoolMonitor.cs
public class ConnectionPoolMonitor : BackgroundService
{
    private readonly ILogger<ConnectionPoolMonitor> _logger;
    private readonly IDbContextFactory<AppDbContext> _factory;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            try
            {
                using var context = _factory.CreateDbContext();
                var connection = context.Database.GetDbConnection();
                
                // SQL Server 特定: 查看连接池统计
                if (connection is SqlConnection sqlConnection)
                {
                    var stats = SqlConnection.ClearAllPools();
                    _logger.LogDebug("Connection pools cleared");
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error monitoring connection pool");
            }
            
            await Task.Delay(TimeSpan.FromMinutes(5), ct);
        }
    }
}

---

最佳实践

✅ 推荐做法

1. 始终使用 using 语句

// ✅ 确保释放
using var context = _factory.CreateDbContext();
var products = await context.Products.ToListAsync();
// 方法结束时自动释放

2. 定期清理 ChangeTracker

// 批量操作中
for (int i = 0; i < totalItems; i++)
{
    // 处理逻辑...
    
    if (i % 100 == 0)
    {
        await context.SaveChangesAsync();
        context.ChangeTracker.Clear();  // ← 关键
    }
}

3. 使用 AsNoTracking

// 只读查询
var products = await context.Products
    .AsNoTracking()
    .Where(p => p.IsActive)
    .ToListAsync();

4. 流式处理大数据

// 避免 ToListAsync()
await foreach (var record in context.Records.AsAsyncEnumerable())
{
    Process(record);
}

5. 启用 DbContext 池化

// Web 应用
builder.Services.AddDbContextPool<AppDbContext>(
    options => options.UseSqlServer(connectionString),
    poolSize: 128);

❌ 避免的错误

1. 不要长期持有 DbContext

// ❌ 错误
public class BadService
{
    private readonly AppDbContext _context;  // ⚠️ 单例持有
    
    public BadService(AppDbContext context)
    {
        _context = context;
    }
}

// ✅ 正确: 使用工厂
public class GoodService
{
    private readonly IDbContextFactory<AppDbContext> _factory;
    
    public GoodService(IDbContextFactory<AppDbContext> factory)
    {
        _factory = factory;
    }
    
    public async Task DoWorkAsync()
    {
        using var context = _factory.CreateDbContext();
        // 使用完立即释放
    }
}

2. 不要忽略异步枚举

// ❌ 错误: 加载所有数据
var allRecords = await context.Records.ToListAsync();
foreach (var record in allRecords)
{
    Process(record);
}

// ✅ 正确: 流式处理
await foreach (var record in context.Records.AsAsyncEnumerable())
{
    Process(record);
}

3. 不要忘记返回 ArrayPool

// ❌ 错误: 内存泄漏
var buffer = ArrayPool<byte>.Shared.Rent(1024);
// 使用后忘记 Return

// ✅ 正确
var buffer = ArrayPool<byte>.Shared.Rent(1024);
try
{
    // 使用 buffer
}
finally
{
    ArrayPool<byte>.Shared.Return(buffer);  // ← 必须
}

---

性能基准测试

[Benchmark]
public async Task WithoutPooling()
{
    using var context = new AppDbContext(options);
    await context.Products.ToListAsync();
}

[Benchmark]
public async Task WithPooling()
{
    using var context = _factory.CreateDbContext();
    await context.Products.ToListAsync();
}

// 结果 (.NET 8):
// | Method          | Mean     | Allocated |
// |---------------- |---------:|----------:|
// | WithoutPooling  | 1.234 ms | 45.2 KB   |
// | WithPooling     | 0.856 ms | 32.1 KB   |
// | Improvement     | 30.6%    | 29.0%     |

---

总结

内存优化决策树

内存问题?
│
├─ ChangeTracker 过大?
│  └─ ✅ 定期 Clear() 或使用短生命周期 DbContext
│
├─ 频繁分配对象?
│  ├─ DbContext → ✅ AddDbContextPool
│  └─ 数组/缓冲区 → ✅ ArrayPool/MemoryPool
│
├─ 大数据集?
│  └─ ✅ AsAsyncEnumerable 流式处理
│
├─ 重复查询相同数据?
│  └─ ✅ 内存缓存/分布式缓存
│
└─ 连接池耗尽?
   └─ ✅ 调整 Min/Max Pool Size

核心要点

1. ChangeTracker: 定期清理,避免膨胀
2. AsNoTracking: 只读查询必用
3. 对象池化: DbContext/Array/Memory
4. 流式处理: 大数据集用 AsAsyncEnumerable
5. 缓存策略: 减少重复查询
6. 及时释放: using 语句确保释放
7. 监控指标: ChangeTracker 大小/池命中率/GC 频率