Hai ứng dụng cùng đọc một bảng dữ liệu lớn, cùng thêm một lớp cache, nhưng một bên giảm mạnh tải database còn bên kia chỉ thêm một vòng round-trip mà không cải thiện gì. Khác biệt nằm ở chiến lược: cache cái gì, TTL bao lâu, và ai chịu trách nhiệm làm mới dữ liệu.
Bài này đi qua bốn chiến lược cache, hai kiểu hết hạn, cách chặn stampede bằng HybridCache, và phần khó nhất — invalidation cùng thiết kế key.
Mục lục
Cập nhật 2026
HybridCache(Microsoft.Extensions.Caching.Hybrid10.11.0) là API nên dùng cho L1 + L2 và stampede protection, thay cho việc tự ghépIMemoryCachevớiIDistributedCache.Microsoft.Extensions.Caching.StackExchangeRedis10.0.14 là implementationIDistributedCachechính thức; Redis server hiện là 8.x.- Output caching và HTTP caching là hai tầng khác nhau;
[ResponseCache]chỉ ghi header, không lưu response trong server. - .NET 8 và .NET 9 hết hỗ trợ ngày 2026-11-10, nên khi lên .NET 10 LTS hãy rà lại chiến lược cache.
Bốn chiến lược cache và ai làm việc gì
Các chiến lược dưới đây không phải bốn lựa chọn ngang hàng của một thư viện. Chúng trả lời câu hỏi khác nhau: ai đọc nguồn, ai ghi cache, và ghi lúc nào.
Cache-aside (look-aside)
Đây là mặc định của phần lớn ứng dụng: ứng dụng tự kiểm tra cache, miss thì đọc database rồi ghi kết quả. Code nằm trong tay bạn, nên bạn kiểm soát TTL, key và cả trường hợp dữ liệu không tồn tại. Cái giá là mỗi lần miss đều là một lần DB, nhiều request đồng thời trên cùng key cùng đọc DB, và hai luồng đọc/ghi cạnh tranh có thể đưa dữ liệu cũ vào cache.
Quy tắc an toàn: sau khi ghi DB thành công thì xóa key, không cập nhật cache trong lúc transaction còn mở.
Read-through
Ứng dụng chỉ nói chuyện với lớp cache; lớp này tự đọc nguồn khi miss. HybridCache.GetOrCreateAsync là dạng read-through: bạn đưa factory, thư viện lo kiểm tra và điền cache. Logic cache không rải rác trong từng service, và thư viện gộp được các lời gọi đồng thời trên cùng key. Read-through không tự giải quyết invalidation — bạn vẫn phải xóa key khi dữ liệu nguồn đổi.
Write-through
Mỗi lần ghi đi cả vào database lẫn cache trong cùng một luồng, nên đọc sau đó gần như luôn trúng cache và nhất quán hơn cache-aside. Cái giá: độ trễ ghi tăng vì thêm một round-trip, và bạn phải xử lý trường hợp ghi DB thành công nhưng ghi cache lỗi — thường là xóa key để lần đọc sau tự điền lại.
Write-through chỉ đúng khi mọi đường ghi đều đi qua ứng dụng. Một job SQL, service khác hay thao tác admin trực tiếp trên database sẽ làm cache sai mà không ai biết, nên luôn cần TTL làm lưới an toàn.
Write-behind (write-back)
Ghi vào cache trước, đẩy việc ghi database sang background. Độ trễ ghi thấp nhất và gộp được nhiều cập nhật, nhưng đổi lại là rủi ro mất dữ liệu khi process chết trước lúc flush và thứ tự ghi khi nhiều worker cùng chạy. Chỉ dùng cho dữ liệu không cần bền vững: đếm lượt xem, presence, thống kê tạm. Không dùng cho đơn hàng, thanh toán, tồn kho; nếu cần ghi bất đồng bộ, để Kafka hay RabbitMQ làm nơi trung chuyển.
| Chiến lược | Nhất quán | Dùng khi |
|---|---|---|
| Cache-aside | Trễ theo TTL, xóa khi ghi | Mặc định read-mostly, kiểm soát chi tiết |
| Read-through | Trễ theo TTL | Gom logic cache một lớp, dùng HybridCache |
| Write-through | Gần nhất quán sau ghi | Cần dữ liệu mới ngay sau ghi |
| Write-behind | Không đảm bảo bền vững | Counter, telemetry, dữ liệu tạm |
TTL: absolute, sliding và jitter
Absolute expiration đặt hạn cố định tính từ lúc ghi cache, nên dữ liệu không bao giờ cũ hơn khoảng thời gian đó, bất kể được đọc bao nhiêu lần. Đây là mặc định tốt cho dữ liệu tham chiếu, cấu hình, danh mục sản phẩm.
Sliding expiration đặt hạn tính từ lần truy cập cuối, nên key nóng có thể sống mãi — dữ liệu cũ tồn tại vô hạn nếu nguồn đổi mà không ai xóa key. Với IMemoryCache, nếu đặt cả hai thì mục vẫn chết ở absolute expiration. Với Redis implementation của IDistributedCache, sliding chỉ trượt khi gọi RefreshAsync. Vì vậy sliding chỉ dùng cho session, luôn kèm absolute cap.
Jitter xử lý trường hợp hàng loạt key được ghi cùng lúc (sau deploy, sau khi flush) nên hết hạn cùng lúc, tạo một đợt sóng request vào database. Cộng thêm 0–120 giây ngẫu nhiên vào TTL là đủ để phân tán các mốc hết hạn — một hàm một dòng cộng Random.Shared.Next vào baseTtl là toàn bộ code cần thiết.
Negative caching: chặn cache penetration
Khi dữ liệu không tồn tại, cache-aside ngây thơ sẽ đọc database mỗi lần, nên ID rác do client gửi sẽ đi xuyên qua cache. Negative cache lưu marker “không tìm thấy” với TTL vài chục giây; dùng một kiểu có trạng thái rõ ràng thay vì null mơ hồ, để phân biệt “không có trong DB” với “chưa từng đọc”. TTL ngắn vì bản ghi có thể được tạo ngay sau đó.
Stampede và thundering herd
Cache stampede là một key nóng hết hạn và hàng trăm request cùng đọc database để tính lại đúng một giá trị. Thundering herd là bản rộng hơn: nhiều key hết hạn cùng lúc, hoặc cả cụm instance khởi động lại với cache rỗng.
Bốn cách chặn:
- Single-flight trong process: chỉ một factory chạy cho mỗi key, các lời gọi khác chờ kết quả.
HybridCachelàm sẵn. - Jitter TTL để phân tán thời điểm hết hạn.
- Stale-while-revalidate: trả bản cũ trong lúc một request làm mới.
- Distributed lock: chỉ một instance tính lại, dùng khi factory rất đắt.
HybridCache gộp các lời gọi đồng thời trong process và ghi kết quả vào cả L1 lẫn L2, nên instance khác thường đọc được bản mới thay vì cùng tính lại. Nó không phải hàng rào tuyệt đối giữa các instance: nếu factory kéo dài và nhiều node cùng miss trước khi node đầu ghi xong L2, vẫn có vài lần gọi trùng. Với dữ liệu đắt và yêu cầu chặt, thêm distributed lock.
// File: Program.cs
using Microsoft.Extensions.Caching.Hybrid;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddStackExchangeRedisCache(options =>
{
options.Configuration = builder.Configuration.GetConnectionString("Redis");
options.InstanceName = "catalog:";
});
builder.Services.AddHybridCache(options =>
{
// Entry lớn hơn ngưỡng này sẽ không được cache
options.MaximumPayloadBytes = 256 * 1024;
options.DefaultEntryOptions = new HybridCacheEntryOptions
{
Expiration = TimeSpan.FromMinutes(10), // L2
LocalCacheExpiration = TimeSpan.FromSeconds(30) // L1
};
});
// File: Features/Catalog/ProductCatalog.cs
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Caching.Hybrid;
public sealed class ProductCatalog(IHybridCache cache, AppDbContext db)
{
public async Task<ProductDto?> GetAsync(Guid tenantId, int id, CancellationToken ct)
{
var key = $"tenant:{tenantId}:product:{id}";
return await cache.GetOrCreateAsync(
key,
async token => await db.Products
.AsNoTracking()
.Where(p => p.TenantId == tenantId && p.Id == id)
.Select(p => new ProductDto(p.Id, p.Name, p.Price))
.FirstOrDefaultAsync(token),
cancellationToken: ct,
options: new HybridCacheEntryOptions
{
Expiration = TimeSpan.FromMinutes(10),
LocalCacheExpiration = TimeSpan.FromSeconds(20)
});
}
// Sau khi commit
public async Task InvalidateAsync(Guid tenantId, int id, CancellationToken ct) =>
await cache.RemoveAsync($"tenant:{tenantId}:product:{id}", ct);
}
Expiration và LocalCacheExpiration là hai tham số quan trọng nhất. L1 ngắn (10–30 giây) giới hạn mức độ cũ trên từng node; L2 dài hơn (5–30 phút) giảm tải database. Nếu để L1 dài bằng L2, invalidation trên một node không có tác dụng với các node khác cho đến khi hết hạn.
Invalidation và thiết kế key
Invalidation quyết định cache có đúng hay không, và cũng là phần bị bỏ qua nhiều nhất. Ba cơ chế cơ bản:
- Xóa theo key khi ghi: chính xác nhưng cần biết key nào bị ảnh hưởng. Một thay đổi danh mục có thể ảnh hưởng nhiều key (danh sách, chi tiết, tìm kiếm).
- Version key: key chứa số phiên bản lấy từ một key khác. Khi dữ liệu đổi, tăng version; toàn bộ key cũ thành rác và tự hết hạn. Không cần liệt kê từng key, nhưng tốn thêm một lần đọc version (cache ngắn ở L1).
- TTL: lưới an toàn cuối cùng, không phải chiến lược chính. TTL một mình nghĩa là bạn chấp nhận dữ liệu cũ đến hết TTL.
Key nên có cấu trúc cố định, có tenant ở đầu, và có phiên bản:
// app:{tenant}:{module}:v{version}:{id}
"app:42:catalog:v3:product:1001"
"app:42:catalog:v3:list:page:2:sort:price"
Vài quy tắc thực tế:
- Tenant id lấy từ claim đã xác thực, không lấy từ query string hay body. Key do client quyết định là lỗ hổng rò rỉ dữ liệu giữa các tenant và là đường cho cache poisoning.
- Không đưa dữ liệu nhạy cảm vào key: key xuất hiện trong log,
MONITORvà dashboard, nên email, số điện thoại, token không nên nằm ở đó. - Chuẩn hóa trước khi ghép key: trim, lowercase phần không phân biệt hoa thường, cố định format số và GUID. Nếu không, “Product:1” và “product:1” là hai key.
- Dùng hash tag khi chạy Redis Cluster:
{tenant:42}:catalog:product:1001giữ các key liên quan trong cùng slot để Lua script và thao tác nhiều key chạy được.
Với HybridCache, RemoveAsync xóa cả L1 của process hiện tại lẫn L2; các instance khác vẫn giữ bản L1 cũ đến khi LocalCacheExpiration hết. Vì vậy phải đặt L1 ngắn cho dữ liệu thay đổi thường xuyên, hoặc thêm backplane pub/sub để báo invalidation — đổi lại là thêm một thành phần có thể lỗi.
Ba tầng còn lại: memory, distributed, HTTP
IMemoryCache nhanh nhất vì không serialize, nhưng sống trong process: mất khi restart, không chia sẻ giữa các instance, dễ OOM nếu không đặt SizeLimit và SetSize.
IDistributedCache là abstraction tối thiểu: chỉ byte[], không get-or-create, không thao tác nguyên tử nhiều key. Nó phù hợp khi cần một chỗ lưu key-value dùng chung, hoặc khi thư viện khác (session, data protection) yêu cầu interface này.
HybridCache bọc cả hai: L1 trong process, L2 qua IDistributedCache bạn đăng ký, có stampede protection và xử lý serialization. Đây là lựa chọn mặc định cho dữ liệu đọc nhiều trong .NET 10.
Output caching lưu toàn bộ response ở phía server. Store mặc định là memory, không dùng IDistributedCache; muốn chia sẻ giữa các instance phải tự cung cấp IOutputCacheStore dựa trên Redis.
// File: Program.cs
builder.Services.AddOutputCache(options =>
{
options.DefaultExpirationTimeSpan = TimeSpan.FromSeconds(30);
options.AddPolicy("catalog", p => p
.Expire(TimeSpan.FromSeconds(30))
.SetVaryByQuery("page", "sort")
.SetVaryByHeader("Accept-Language"));
});
app.UseOutputCache();
app.MapGet("/products", async (int page, string? sort, ProductCatalog catalog, CancellationToken ct) =>
{
var items = await catalog.ListAsync(page, sort, ct);
return Results.Ok(items);
}).CacheOutput("catalog");
HTTP caching là tầng khác hẳn: bạn gửi Cache-Control và ETag để client hoặc CDN giữ bản sao, còn server không lưu gì. [ResponseCache] chỉ ghi các header này; VaryByQueryKeys chỉ có tác dụng khi bật response caching middleware.
ETag + If-None-Match trả 304 giúp tiết kiệm băng thông, nhưng nếu endpoint vẫn truy vấn database để tính ETag thì bạn chỉ tiết kiệm băng thông chứ không tiết kiệm CPU. Hãy tính ETag từ một version hoặc timestamp có sẵn.
// File: Endpoints/FeedEndpoints.cs
app.MapGet("/feed", async (HttpContext http, FeedService feed, CancellationToken ct) =>
{
var payload = await feed.GetAsync(ct);
var etag = $"\"{payload.Version}\""; // Version tăng mỗi lần nội dung đổi
http.Response.Headers.CacheControl = "public, max-age=60";
http.Response.Headers.ETag = etag;
if (http.Request.Headers.IfNoneMatch == etag)
return Results.StatusCode(StatusCodes.Status304NotModified);
return Results.Ok(payload.Items);
});
Observability: hit ratio không phải chỉ số duy nhất
Hit ratio toàn cục thường đẹp và vô dụng: một key nóng chiếm phần lớn request có thể che giấu việc toàn bộ nhóm key còn lại luôn miss. Hãy đo theo nhóm key và đo cả chi phí miss — thời gian factory, số query DB phát sinh:
- Hit ratio theo nhóm key để biết nhóm nào cache không có tác dụng.
- p95 latency endpoint: cache phải cải thiện số này, không chỉ giảm QPS database.
- Số lần factory chạy: cao bất thường nghĩa là TTL quá ngắn hoặc invalidation quá tay.
- Bộ nhớ và eviction:
evicted_keystrên Redis, số entry bị đẩy khỏiIMemoryCache.
Khi nào không nên cache
Cache là một bản sao, và mọi bản sao đều có thể sai. Đừng tạo bản sao khi cái sai đó không chấp nhận được: dữ liệu phụ thuộc role hoặc permission (key phải chứa đủ ngữ cảnh, hoặc không cache), bất biến tài chính như số dư và tồn kho, luồng ghi nhiều hơn đọc, payload vượt MaximumPayloadBytes, và dữ liệu có hit rate thấp.
2027: cache ngày càng gần framework hơn
.NET 11 dự kiến GA tháng 11/2026 (STS), và hướng đi là các abstraction cache cấp cao hơn thay vì tự ghép interface. HybridCache đã là mặc định trong .NET 10; kỳ vọng tiếp theo là invalidation, telemetry và output cache dùng store phân tán được chuẩn hóa. Việc nên làm ngay là chuyển những chỗ tự viết cache-aside sang HybridCache để có stampede protection và cấu hình L1/L2 rõ ràng.
Checklist
- Chọn chiến lược theo đường ghi: cache-aside hoặc read-through cho read-mostly, write-through khi cần mới ngay, write-behind chỉ cho dữ liệu tạm.
- Mọi entry có absolute TTL; sliding chỉ kèm absolute cap và chỉ cho session.
- Thêm jitter vào TTL và negative cache TTL ngắn cho ID không tồn tại.
- Key có tenant ở đầu, có version; tenant lấy từ claim đã xác thực.
- Xóa key sau khi commit; với
HybridCacheđặt L1 ngắn hơn L2. - Đo hit ratio theo nhóm key trước khi tăng TTL để “cải thiện hiệu năng”.
Đọc tiếp: Cache in-memory vs cache phân tán để chọn tầng lưu trữ; Sử dụng Redis trong ASP.NET Core để triển khai L2; và Second-level caching trong EF Core để so sánh cache ở tầng ORM.



