lock và SemaphoreSlim bảo vệ một biến trong một process. Khi bạn chạy thêm container thứ hai, hai cơ chế đó không còn liên quan gì đến nhau, và đoạn code “đã khóa” bắt đầu sai một cách ngẫu nhiên. Distributed lock giải quyết việc đó — nhưng nó không phải lựa chọn đầu tiên, và không phải lúc nào cũng là lựa chọn đúng.
Bài này đi từ lý do lock trong process thất bại, cách triển khai Redis an toàn, RedLock và fencing token — thứ thực sự bảo vệ dữ liệu khi instance treo lâu hơn lease.
Cập nhật 2026:
- Redis 8 là server hiện hành; client .NET dùng
StackExchange.Redis3.4.31, đã có sẵnLockTakeAsync/LockReleaseAsyncthay vì phải tự viết Lua cho hai thao tác cơ bản. - Với .NET 10, cách viết được khuyến nghị là dùng abstraction
IDistributedLockcủaMedallion.Threading(packageDistributedLock.Redis), không tự quản lý token và TTL bằng tay. - RedLock vẫn không đủ cho dữ liệu tài chính: thiếu fencing token thì mutual exclusion không bảo vệ được gì (Kleppmann, 2016).
Mục lục
Vì sao lock in-process không cứu bạn
Xét một service trừ tồn kho. Trên một instance, cách viết sau là đúng:
// File: InventoryService.cs
public sealed class InventoryService
{
private static readonly object Gate = new();
private int _stock = 100;
public bool TryDecrease(int amount)
{
lock (Gate) // chỉ bảo vệ bên trong process này
{
if (_stock < amount) return false;
_stock -= amount; // mỗi instance có _stock riêng
return true;
}
}
}
Scale lên ba replica: cả ba đều thấy “còn hàng”, cả ba đều trừ, kho thành âm. Gate là static nhưng chỉ trong một process — hai container là hai heap và hai monitor độc lập.
Sticky session chỉ giảm xác suất hai request của cùng người dùng rơi vào hai instance; hai người dùng khác nhau vẫn tranh nhau cùng một mặt hàng.
Một lock phân tán đúng cần gì
- Mutual exclusion — một thời điểm chỉ một client giữ khóa cho một resource.
- Lease (TTL) — client crash thì khóa tự hết hạn; không có TTL là deadlock vĩnh viễn.
- Token — mỗi lần giành khóa sinh giá trị duy nhất; chỉ người giữ token được release hoặc gia hạn.
- Renewal — tác vụ dài hơn TTL phải gia hạn, và việc gia hạn cũng kiểm tra token.
- Fencing — resource từ chối thao tác của người giữ khóa cũ. Phần quan trọng nhất và hay bị bỏ nhất.
Lý do cần fencing: client A giành khóa TTL 30 giây rồi bị GC pause hoặc VM freeze 45 giây. Lease hết hạn, B giành khóa và bắt đầu ghi; A tỉnh lại, tin mình vẫn giữ khóa, và ghi tiếp. Lock không ngăn được vì lúc A tỉnh, khóa đã thuộc về B hợp lệ — chỉ storage kiểm tra token mới sửa được.
Redis: SET NX PX, token và release nguyên tử
Nguyên tắc: giành khóa là một lệnh nguyên tử duy nhất (SET key token NX PX ttl), release phải là compare-and-delete nguyên tử, không phải GET rồi DEL.
// File: RedisLock.cs
using StackExchange.Redis;
public sealed class RedisLock(IConnectionMultiplexer redis)
{
private readonly IDatabase _db = redis.GetDatabase();
public async Task<string?> TryAcquireAsync(string resource, TimeSpan lease)
{
var token = Guid.NewGuid().ToString("N");
var acquired = await _db.StringSetAsync(
key: $"lock:{resource}", value: token,
expiry: lease, when: When.NotExists); // SET ... NX PX <ms>
return acquired ? token : null;
}
private const string ReleaseScript = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('del', KEYS[1])
end
return 0
""";
public async Task<bool> ReleaseAsync(string resource, string token)
{
var keys = new RedisKey[] { $"lock:{resource}" };
var values = new RedisValue[] { token };
var result = await _db.ScriptEvaluateAsync(ReleaseScript, keys, values);
return (long)result == 1;
}
}
Với đúng hai thao tác này, bạn không cần viết script: _db.LockTakeAsync(key, token, lease) và _db.LockReleaseAsync(key, token) làm chính xác việc trên. Viết tay chỉ đáng khi bạn cần logic phụ, ví dụ gia hạn:
private const string RenewScript = """
if redis.call('get', KEYS[1]) == ARGV[1] then
return redis.call('pexpire', KEYS[1], ARGV[2])
end
return 0
""";
public async Task<bool> RenewAsync(string resource, string token, TimeSpan lease)
{
var keys = new RedisKey[] { $"lock:{resource}" };
var values = new RedisValue[] { token, (long)lease.TotalMilliseconds };
return (long)await _db.ScriptEvaluateAsync(RenewScript, keys, values) == 1;
}
Bốn lỗi thực tế với Redis lock:
- Release không kiểm tra token.
DEL lock:xsau khi lease hết hạn sẽ xóa khóa của người khác — luôn compare-and-delete. - Gia hạn bằng
SET ... XX PX. Lệnh này ghi đè value bằng token của bạn dù khóa đang thuộc người khác. Phải dùng script kiểm tra token như trên. - TTL quá ngắn hoặc quá dài. Quá ngắn thì mất khóa giữa việc, quá dài thì deadlock kéo dài sau crash. Đặt theo p99 thời gian tác vụ và bật renewal cho phần đuôi phân bố.
- Quên failover. Replication là bất đồng bộ: master chết trước khi SET kịp replicate thì khóa biến mất và hai client có thể cùng giành; Sentinel/cluster không sửa được cửa sổ này.
RedLock và những giả định của nó
RedLock dùng N node Redis độc lập (thường N = 5): client xin khóa trên từng node với cùng token và TTL, thành công khi giành quá nửa số node trong thời gian ngắn hơn TTL, thất bại thì release tất cả. Package .NET tương ứng là RedLock.net.
- Các node phải độc lập thật; chạy trên node của cùng một Redis Cluster là tự lừa mình, vì cluster chia slot chứ không nhân bản độc lập cho từng key.
- Đồng hồ phải lệch trong biên cho phép và mọi thao tác phải nhanh hơn TTL — một GC pause dài, VM suspend hay NTP nhảy giờ phá giả định.
- Client không biết mình bị treo quá lease, nên vẫn cần fencing token.
Kleppmann lập luận năm 2016 rằng RedLock không đủ cho các case cần correctness (tài chính, tồn kho) và khuyến nghị fencing token; antirez phản hồi tập trung vào hiệu quả và xác suất. Thực dụng: RedLock hợp lý khi chỉ cần giảm chạy trùng (gửi email, tạo báo cáo), và sai khi một lần sai là hỏng dữ liệu — trừ khi storage kiểm tra fencing.
Fencing token: phần bảo vệ thật sự
Lock service cấp số tăng đơn điệu mỗi lần trao khóa; mọi write kiểm tra số đó, write đến muộn với số cũ bị từ chối bất kể client tin mình đang giữ khóa. Nguồn số có thể là INCR trên Redis, revision của etcd, hoặc một bảng database.
-- inventory có cột fence BIGINT NOT NULL DEFAULT 0
UPDATE inventory
SET quantity = quantity - @amount,
fence = @newFence
WHERE id = @id
AND fence < @newFence
AND quantity >= @amount;
0 row nghĩa là bạn đã mất quyền ghi vì một holder mới đã ghi trước. Fencing chỉ có giá trị khi mọi đường ghi đều đi qua kiểm tra này; một endpoint admin update trực tiếp sẽ vô hiệu hóa toàn bộ cơ chế.
Medallion.Threading: đừng tự viết lại
Viết đúng acquire/release/renew bằng tay rất dễ sai ở các nhánh lỗi. Package DistributedLock.Redis (namespace Medallion.Threading.Redis) cung cấp IDistributedLockProvider với handle API, pin version trong Directory.Packages.props theo bản stable trên NuGet.
// File: Program.cs (đăng ký)
using Medallion.Threading;
using Medallion.Threading.Redis;
builder.Services.AddSingleton<IConnectionMultiplexer>(_ =>
ConnectionMultiplexer.Connect(builder.Configuration.GetConnectionString("Redis")!));
builder.Services.AddSingleton<IDistributedLockProvider>(sp =>
new RedisDistributedSynchronizationProvider(
sp.GetRequiredService<IConnectionMultiplexer>().GetDatabase()));
// File: ReportJob.cs (sử dụng)
public sealed class ReportJob(IDistributedLockProvider locks)
{
public async Task RunAsync(DateOnly day, CancellationToken ct)
{
await using var handle = await locks
.CreateLock($"report:{day:yyyy-MM-dd}")
.AcquireAsync(TimeSpan.FromSeconds(5), ct);
// chỉ một instance chạy tại một thời điểm
}
}
Handle dispose sẽ release kể cả khi có exception. Provider Redis có option riêng cho expiry và chu kỳ gia hạn (RedisDistributedLockOptions) — đọc kỹ thay vì giả định nó tự gia hạn vô hạn. Medallion cũng có provider Postgres/SQL Server, nên đổi backend không phải sửa call site.
Database: advisory lock và row lock
Nếu bạn đã có Postgres, pg_advisory_xact_lock là lock phân tán rẻ nhất — không cần hạ tầng mới, và khóa tự nhả khi transaction kết thúc:
// File: OrderImporter.cs
var key = BitConverter.ToInt64(tenantId.ToByteArray(), 0);
await using var tx = await db.Database.BeginTransactionAsync(ct);
await db.Database.ExecuteSqlInterpolatedAsync(
$"SELECT pg_advisory_xact_lock({key})", ct);
// đọc/ghi trong cùng transaction; commit hoặc rollback đều nhả khóa
await tx.CommitAsync(ct);
Dùng key ổn định (Guid.GetHashCode() không giống nhau giữa các process). Bản pg_advisory_lock là session-level, gắn với connection: với PgBouncer transaction mode hoặc pool, khóa có thể nằm ở connection bạn không còn kiểm soát — ưu tiên bản _xact_.
SQL Server có sp_getapplock với @LockOwner = 'Transaction'; giá trị âm là thất bại. Row lock (SELECT ... FOR UPDATE) chỉ đúng khi bản ghi tồn tại: hai transaction cùng khóa một id chưa có sẽ cùng thấy rỗng rồi cùng INSERT, nên vẫn cần unique index.
Idempotency không phải lock, và lock không phải exactly-once
Lock giảm khả năng hai instance làm cùng việc tại cùng thời điểm, nhưng không làm tác vụ chạy đúng một lần: message có thể giao lại, HTTP request có thể retry, transaction có thể commit rồi timeout trước khi client nhận phản hồi. Retry an toàn cần idempotency key cộng unique index (INSERT ... ON CONFLICT DO NOTHING; SQL Server bắt lỗi 2601/2627). Với side effect bên ngoài (email, payment), dùng transactional outbox: ghi ý định trong cùng transaction, worker publish ít nhất một lần và consumer idempotent. Lock không thay được hai thứ này; idempotency thường làm lock khỏi cần thiết.
Khi bạn không cần lock
Phần lớn tranh chấp trong ứng dụng web không cần lock phân tán, chỉ cần một câu lệnh nguyên tử hoặc một ràng buộc:
- Điều kiện trong UPDATE.
UPDATE ... WHERE quantity >= @amount; số row trả về cho biết thành công. EF Core 10 diễn đạt việc này bằngExecuteUpdateAsync. - Unique index. Chống tạo trùng bản ghi mạnh hơn mọi lock, vì nó đúng cả khi process chết giữa chừng.
- Optimistic concurrency.
rowversion/xmin+ retry khi conflict; phù hợp khi xung đột hiếm. - Phân vùng theo key. Với Kafka, mỗi partition chỉ có một consumer; dùng partition key thay vì khóa toàn cục.
- Một writer duy nhất. Thiết kế để một service sở hữu một loại dữ liệu, hoặc dùng leader election thay vì lock từng job.
Code dưới đây thay cho cả một lock manager trong case tồn kho:
var rows = await db.Products
.Where(p => p.Id == id && p.Stock >= amount)
.ExecuteUpdateAsync(s => s.SetProperty(p => p.Stock, p => p.Stock - amount), ct);
if (rows == 0)
{
// hết hàng, hoặc instance khác vừa lấy mất phần còn lại
}
Observability: đo contention, không chỉ log lỗi
Lock là điểm nghẽn tiềm năng: cần biết ai chờ bao lâu, giữ bao lâu, bao nhiêu lần thất bại, có lần gia hạn nào fail. System.Diagnostics.Metrics đi ra OpenTelemetry không cần thêm thư viện:
// File: LockMetrics.cs
using System.Diagnostics.Metrics;
public static class LockMetrics
{
private static readonly Meter Meter = new("Evotek.Locking", "1.0");
public static readonly Counter<long> Attempts = Meter.CreateCounter<long>("lock.acquire.attempts");
public static readonly Counter<long> Failures = Meter.CreateCounter<long>("lock.acquire.failures");
public static readonly Counter<long> RenewFailures = Meter.CreateCounter<long>("lock.renew.failures");
public static readonly Histogram<double> Wait = Meter.CreateHistogram<double>("lock.acquire.wait", unit: "ms");
}
Ghi Wait quanh lần acquire kèm tag resource, và đo cả thời gian giữ khóa. Hai alert đáng có: renewal fail (bạn có thể đã mất khóa giữa tác vụ) và p95 chờ vượt ngưỡng (lock đang serialize quá nhiều việc — thu hẹp critical section trước khi tăng TTL).
Chọn giải pháp
| Giải pháp | Dùng khi | Tránh khi |
|---|---|---|
| Redis SET NX PX + token | Cần lock nhanh, đã có Redis, chấp nhận rủi ro failover | Cần correctness tuyệt đối mà storage không kiểm tra fencing |
| Postgres advisory lock | Đã có Postgres, tác vụ gắn với transaction | Tác vụ dài giữ transaction mở, hoặc qua PgBouncer transaction mode |
Medallion IDistributedLock |
Muốn API thống nhất, đổi backend được, ít code tự viết | Cần hành vi đặc biệt mà provider không hỗ trợ |
| RedLock | Giảm chạy trùng, có nhiều node độc lập thật | Dữ liệu tài chính, tồn kho, mọi nơi cần đúng tuyệt đối |
| Không lock | Có thể diễn đạt bằng UPDATE có điều kiện, unique index, idempotency | Khi đã kiểm tra và thấy tranh chấp thật sự cần tuần tự hóa |
Checklist
- Không dùng
lock/SemaphoreSlimcho state dùng chung giữa các instance. - Mọi acquire có TTL và token; release là compare-and-delete bằng Lua.
- Gia hạn kiểm tra token; tác vụ dài hơn TTL có renewal và metric cho renewal fail.
- Storage kiểm tra fencing token ở mọi đường ghi quan trọng.
- Idempotency key + unique index cho tác vụ có thể retry; outbox cho side effect.
- Theo dõi wait time, hold time, failure rate; alert khi p95 chờ vượt ngưỡng.
Hướng tới 2027: .NET 11 dự kiến GA trong tháng 11/2026 (STS), nhưng mô hình lock không đổi. Điều thay đổi là observability — metric và trace qua OpenTelemetry thành mặc định, nên thiết kế lock có số liệu ngay từ đầu.
Đọc tiếp trong series:
- Sử dụng Redis trong ASP.NET Core — cấu hình kết nối, key naming và các mẫu thiết kế nền tảng cho lock.
- Cache in-memory vs cache phân tán — cùng hạ tầng Redis nhưng mục tiêu khác: cache sai thì chậm, lock sai thì hỏng dữ liệu.
- Messaging với RabbitMQ, Kafka và Azure Service Bus — khi nào dùng competing consumer và partition thay cho lock.



