Aynı bakiyeden iki kez harcama nasıl önlenir?
Aynı anda gelen iki istek bakiyeyi eksiye düşürebilir. SQL Server ve EF Core'da UPDLOCK, koşullu UPDATE ve rowversion ile bakiyeyi korumak.

10 dk okuma

İçindekiler
- Bakiye nasıl eksiye düşer?
- Transaction’a sarmak neden yetmez?
- Satır kilidi: UPDLOCK
- Tek koşullu UPDATE
- Rowversion: aynı anda tek işlem
- Bugün hangisini seçerim?
- Redis kilidi yeterli mi?
- İki isteği gerçekten yarıştıran test
- Reddedilen işlem tekrar denenince
- Sık sorulanlar
- Transaction’a sarmak race condition’ı önler mi?
- Bakiye için optimistic mi, pessimistic locking mi?
- Redis distributed lock bakiye için yeterli mi?
- DbUpdateConcurrencyException gelince ne yapmalı?
Aynı müşteriden aynı anda iki istek geldi. İkisi de bizim bakiye kontrolümüzden geçti. Biri bankaya gitti ve “bakiye yetersiz” diye geri döndü. Müşteri ekranda bir hata mesajı gördü ve şikâyet etti. Biz sorunu o şikâyetten öğrendik.
Kodda bariz bir hata yoktu. Bakiyeyi okuyor, yetip yetmediğine bakıyor, sonra düşüyorduk. Tek başına çalışan bir istek için bu doğru. Sorun, aynı hesap için iki isteğin aynı anda çalışmasıydı.
Kısa cevap: bakiyeyi önce okuyup sonra ayrı bir komutla düşme. Kontrolü ve düşümü tek bir atomik veritabanı işlemine koy. Bunun üç yolu var: okurken satırı kilitlemek (UPDLOCK, PostgreSQL’de FOR UPDATE), kontrolü UPDATE’in WHERE koşuluna taşımak ya da satırın sürümünü (rowversion) kontrol etmek. Transaction’a sarmak tek başına yetmez.
Bakiye nasıl eksiye düşer?
Bu hatanın adı race condition: sonuç, iki işlemin hangi sırayla çalıştığına bağlı. Bakiyede aldığı şekle check-then-act deniyor. Önce kontrol ediyorsun, sonra o kontrole göre davranıyorsun. Arada başka biri değeri değiştirirse, kontrolün artık geçerli değil.
Tipik kod şöyle görünür:
var account = await db.Accounts.SingleAsync(a => a.Id == accountId, ct);
if (account.Balance < amount)
return WithdrawResult.InsufficientBalance;
account.Balance -= amount;
await db.SaveChangesAsync(ct);
Bakiye 100 ₺ olsun ve aynı anda iki tane 70 ₺’lik istek gelsin:
İki istek de bakiyeyi okuyor ve 100 ₺ görüyor. İkisi de “yeter” diyor. İlki 70 ₺ düşüyor. İkincisi de düşüyor, çünkü kendi gözünde bakiye hâlâ 100 ₺.
Sonuç, düşümün nasıl yazıldığına göre değişir. EF Core yukarıdaki kodda yeni değeri hesaplayıp yazar: SET Balance = 30. İki istek de 30 yazar ve iki harcamadan biri kaybolur (lost update). SET Balance = Balance - 70 gibi göreli bir düşüm yazsaydın bakiye −40 olurdu. İkisi de yanlış. Para ya kayboluyor ya da olmayan para harcanıyor.
Bu hata testte nadiren çıkar. Elle denerken istekler arka arkaya gelir, aynı anda değil. Canlıda ise çift tıklama, retry yapan bir istemci ya da iki cihazdan aynı anda işlem yapan bir kullanıcı bunu yeterince sık üretir.
Transaction’a sarmak neden yetmez?
İlk akla gelen çözüm, okumayı ve yazmayı bir transaction’a koymak. Bizim de ilk adımımız buydu.
Ama SQL Server’ın varsayılan izolasyon seviyesi Read Committed. Bu seviyede SELECT okuduğu satıra paylaşımlı bir kilit koyar ve okuma biter bitmez bırakır. İkinci istek de aynı satırı rahatça okur. Transaction’ın içinde olmak, iki isteğin aynı eski değeri görmesini engellemez. PostgreSQL’de de varsayılan seviye Read Committed ve sonuç aynı.
İzolasyonu yükseltmek de istediğin şeyi vermez. SQL Server’da Repeatable Read ya da Serializable’da iki istek okuma kilitlerini tutar, sonra ikisi de yazmak ister ve biri deadlock kurbanı olur. Eksi bakiye engellenir, ama karşılığında bir hata alırsın ve bunu her yerde yakalaman gerekir.
Transaction gerekli, ama yetmiyor. Asıl soru, ikinci isteğin eski değeri görmesini nasıl engelleyeceğin.
Satır kilidi: UPDLOCK
Bizim çözümümüz, bakiyeyi okurken satırı kilitlemekti. SQL Server’da bunu UPDLOCK tablo ipucu yapar:
BEGIN TRANSACTION;
SELECT Balance
FROM Accounts WITH (UPDLOCK, ROWLOCK)
WHERE Id = @accountId;
-- uygulama bakiyeyi kontrol eder
UPDATE Accounts
SET Balance = Balance - @amount
WHERE Id = @accountId;
COMMIT;
UPDLOCK satıra bir güncelleme kilidi koyar ve bu kilit transaction bitene kadar kalır. İkinci istek aynı satırı UPDLOCK ile okumak istediğinde bekler. İlki commit edince okur ve artık 30 ₺ görür. Kontrol başarısız olur, istek reddedilir.
EF Core’da bunu ham SQL ile yaparsın:
await using var tx = await db.Database.BeginTransactionAsync(ct);
var account = await db.Accounts
.FromSql($"SELECT * FROM Accounts WITH (UPDLOCK, ROWLOCK) WHERE Id = {accountId}")
.SingleAsync(ct);
if (account.Balance < amount)
return WithdrawResult.InsufficientBalance;
account.Balance -= amount;
await db.SaveChangesAsync(ct);
await tx.CommitAsync(ct);
PostgreSQL’de karşılığı SELECT ... FOR UPDATE (açık kilitleme).
Bunun bir bedeli var. İkinci istek beklerken bir bağlantıyı ve bir thread’i tutar. Kilidin içinde ne kadar iş yaparsan bekleme o kadar uzar. O yüzden kilidin içinde bankaya ya da başka bir servise çağrı yapma; yalnızca oku, kontrol et, yaz. Bir de WHERE koşulunun indeksli bir kolona, burada birincil anahtara gitmesi gerekir. Yoksa SQL Server satırları tarar ve fazlasını kilitler (bkz. SQL Server’da yavaş sorgu).
UPDLOCK işimizi gördü. Ama bugün olsa önce başka bir yola bakarım.
Tek koşullu UPDATE
Kontrolü uygulamada yapmak yerine UPDATE’in içine koyabilirsin:
UPDATE Accounts
SET Balance = Balance - @amount
WHERE Id = @accountId
AND Balance >= @amount;
Komut ya bir satırı günceller ya da hiçbirini. Etkilenen satır sayısı 0 ise bakiye yetmiyordur. Ayrı bir okuma yok, o yüzden araya girilecek bir boşluk da yok.
İki istek aynı anda gelirse ne olur? İlk UPDATE satırı kilitler. İkincisi bekler, ilki commit edince satırı yeniden okur ve koşulu güncel değerle değerlendirir. 30 ≥ 70 tutmaz, satır güncellenmez. SQL Server da PostgreSQL de bu şekilde çalışır.
EF Core 7’den beri bunu ExecuteUpdateAsync ile entity yüklemeden yazabilirsin:
var updated = await db.Accounts
.Where(a => a.Id == accountId && a.Balance >= amount)
.ExecuteUpdateAsync(s => s.SetProperty(a => a.Balance, a => a.Balance - amount), ct);
if (updated == 0)
return WithdrawResult.InsufficientBalance;
Bu yol kısa ve kilidi en kısa sürede bırakıyor. Bir sınırı var: bakiye iki isteğe de yetiyorsa ikisini de geçirir. Çoğu sistem için doğru davranış bu. Benim için değil.
Rowversion: aynı anda tek işlem
Bence bir kullanıcının aynı hesaptan aynı anda iki işlem yapmasına izin vermemek gerekiyor. Bakiye ikisine de yetse bile.
Bunu satırın sürümüyle yaparsın. SQL Server’da rowversion kolonu, satır her değiştiğinde veritabanının kendiliğinden artırdığı bir değerdir. EF Core’da bu bir concurrency token:
public class Account
{
public Guid Id { get; set; }
public decimal Balance { get; set; }
[Timestamp]
public byte[] RowVersion { get; set; } = [];
}
Token tanımlıysa EF Core SaveChangesAsync’te UPDATE’e WHERE RowVersion = @eskiDeger ekler. Sen okuduktan sonra başka biri satırı değiştirdiyse güncellenen satır sayısı 0 olur ve EF Core DbUpdateConcurrencyException fırlatır. Bu, iyimser kilitlemedir (optimistic concurrency): kimse beklemez, çakışan taraf hata alır.
PostgreSQL’de ayrı bir kolon gerekmez. Npgsql, her satırda zaten bulunan xmin sistem kolonunu token olarak kullanabilir:
public uint Version { get; set; }
// OnModelCreating
modelBuilder.Entity<Account>().Property(a => a.Version).IsRowVersion();
Bugün hangisini seçerim?
Koşullu UPDATE ile rowversion’ı birlikte kullanırım. Koşul bakiyeyi korur, sürüm de aynı anda tek işlemi.
var account = await db.Accounts
.AsNoTracking()
.SingleAsync(a => a.Id == accountId, ct);
var updated = await db.Accounts
.Where(a => a.Id == accountId
&& a.RowVersion == account.RowVersion
&& a.Balance >= amount)
.ExecuteUpdateAsync(s => s.SetProperty(a => a.Balance, a => a.Balance - amount), ct);
if (updated == 1)
return WithdrawResult.Success;
// Neden 0? Ya bakiye yetmedi ya da arada başka bir işlem satırı değiştirdi.
return account.Balance < amount
? WithdrawResult.InsufficientBalance
: WithdrawResult.ConcurrentOperation;
İki istek aynı anda gelirse ikisi de aynı sürümü okur. İlki sürümü değiştirir, ikincisinin WHERE koşulu tutmaz. Bakiye 200 ₺ olsa da ikinci istek reddedilir. İki durumu ayırıyorum, çünkü kullanıcıya gösterilecek mesaj farklı: biri “bakiye yetersiz”, diğeri “devam eden bir işleminiz var”.
Bunun da bir bedeli var. Saniyede çok sayıda işlem gören bir hesapta, örneğin sürekli tahsilat alan bir işyeri hesabında, isteklerin çoğu çakışmaya düşer. O hesaplar için tek satırdaki bakiyeyi güncellemek zaten iyi bir model değil. Bunu serinin ikinci yazısında, hareket tablosu (ledger) üzerinden anlatacağım.
Redis kilidi yeterli mi?
Bu sorun için sık önerilen bir çözüm daha var: hesap üzerine Redis’te dağıtık bir kilit. O sistemde Redis yoktu, o yüzden bizim masamıza hiç gelmedi. Ama bakiye için tek başına güvenmezdim.
Kilidin bir süresi (TTL) vardır. İşlem bu süreden uzun sürerse kilit sen bitirmeden açılır ve ikinci istek içeri girer. Uygulama bir GC duraklamasında ya da ağ gecikmesinde takılırsa kilidin hâlâ sende olduğunu sanarak yazmaya devam eder. Martin Kleppmann bu durumu ayrıntılı anlatıyor. Çözümü olan fencing token, sonunda yine veritabanının yazmayı kontrol etmesine dayanıyor.
Redis kilidi gereksiz işi azaltabilir. Asıl garanti yine veritabanında olmalı. Bunu idempotency yazısında da yaşamıştık: kilit tekrarı durdurur, sonucu vermez.
İki isteği gerçekten yarıştıran test
Bu hatayı sırayla çalışan bir testle yakalayamazsın. İstekleri aynı anda göndermen ve her birine ayrı bir DbContext vermen gerekir. Testi de gerçek bir veritabanında çalıştır. EF Core’un InMemory sağlayıcısı kilit ve transaction davranışını taklit etmez.
[Fact]
public async Task Ayni_anda_gelen_istekler_bakiyeyi_eksiye_dusurmez()
{
var accountId = await SeedAccountAsync(balance: 100m);
var results = await Task.WhenAll(Enumerable.Range(0, 20).Select(_ => Task.Run(async () =>
{
await using var db = CreateDbContext();
return await new WithdrawHandler(db).HandleAsync(accountId, amount: 70m, CancellationToken.None);
})));
Assert.Single(results, r => r == WithdrawResult.Success);
await using var check = CreateDbContext();
var account = await check.Accounts.SingleAsync(a => a.Id == accountId);
Assert.Equal(30m, account.Balance);
}
Bu testi ilk koddaki oku-kontrol et-yaz versiyonuyla çalıştırırsan sonuç her seferinde aynı çıkmayabilir. Yarışı görünür kılmak için okuma ile yazma arasına kısa bir Task.Delay koyabilirsin. Düzeltilmiş versiyon ise her çalıştırmada tek başarılı istek ve 30 ₺ bakiye vermeli.
Reddedilen işlem tekrar denenince
Reddedilen istek bir hata mesajıyla dönüyor. Bizim olayda da müşteri bunu gördü. Ama bu reddin ne anlama geldiği, isteğin ne olduğuna bağlı.
Kullanıcı butona iki kez bastıysa ikinci istek aynı işlemin tekrarıdır. Ona hata vermek yerine ilk işlemin sonucunu dönmek gerekir. Bunu idempotency key ile yaparsın ve yazının konusu bu değil; ayrıntısı burada. Gerçekten iki ayrı işlemse, ikinciyi reddetmek doğru. İstemci daha sonra tekrar deneyebilir, çünkü bakiye düşülmedi.
DbUpdateConcurrencyException aldığında da aynı isteği aynı eski sürümle tekrar gönderme. Tekrar denemek istiyorsan bakiyeyi yeniden oku, kontrolü yeniden yap. Eski okumayla yeniden denemek, korumaya çalıştığın hatayı geri getirir.
Sık sorulanlar
Transaction’a sarmak race condition’ı önler mi?
Varsayılan Read Committed seviyesinde önlemez. İki istek aynı satırı okuyabilir ve ikisi de eski değere göre karar verir. Okumayı UPDLOCK ya da FOR UPDATE ile kilitlemen ya da kontrolü UPDATE’in WHERE koşuluna taşıman gerekir.
Bakiye için optimistic mi, pessimistic locking mi?
Çakışma nadirse optimistic (rowversion) daha az bekletir ve daha iyi ölçeklenir. Çakışma sıksa ve isteklerin sırayla işlenmesi gerekiyorsa pessimistic (UPDLOCK) daha az hata üretir. Yalnızca bakiyenin eksiye düşmemesi gerekiyorsa koşullu UPDATE ikisinden de basit.
Redis distributed lock bakiye için yeterli mi?
Tek başına değil. Kilidin süresi işlemden kısa kalabilir ve uygulama kilidi kaybettiğini fark etmeden yazmaya devam edebilir. Kilit gereksiz yükü azaltabilir, ama kontrol yine veritabanında olmalı.
DbUpdateConcurrencyException gelince ne yapmalı?
Kullanıcıya devam eden bir işlem olduğunu söyle ya da bakiyeyi yeniden okuyup kontrolü baştan yap. Aynı eski değerle yeniden denemek güvenli değil.
Bakiyeyi tek satırda tutup her işlemde güncellemek bu yazıdaki korumalarla güvenli hâle gelir. Ama işlem geçmişini, iadeyi ve mutabakatı da bu satırdan çıkarmaya çalıştığında model zorlanmaya başlar. Serinin ikinci yazısında bakiyeyi bir sayı olarak değil, hareketlerin toplamı olarak tutmayı anlatacağım.
Sıradaki yazı gelen kutuna düşsün
Yazı yayımlandığı sabah, aşağıdaki gibi tek bir mail. Genelde haftada iki.
Hüseyin Bozdemir10:00
Aynı bakiyeden iki kez harcama nasıl önlenir?
Aynı anda gelen iki istek bakiyeyi eksiye düşürebilir. SQL Server ve EF Core'da UPDLOCK, koşullu UPDATE ve rowversion ile bakiyeyi korumak.
Onay maili gelir, bağlantıya tıklayınca abonelik başlar. Her mailin altından tek tıkla ayrılabilirsin. Verilerin
Benzer yazılar

12 dk
Outbox pattern nedir? .NET ve EF Core ile
Outbox pattern nedir? RabbitMQ yokken EF Core tablosu ve .NET BackgroundService ile transactional outbox: çift işleme, retry, para çıkışı.

13 dk
Idempotency nedir? Ödemede para iki kez çekilmesin
Idempotency, aynı istek tekrar gelse de sonucun değişmemesidir. Ödemede çift tıklamaya ve banka timeout'una karşı .NET'te idempotency key ile çözüm.

4 dk
Feature flag teknik borca nasıl dönüşür?
Tek bir müşteri için açılan feature flag uzun süre kodda kalır. Tenant bazlı flag'lerin bedeli, temizliği ve yeni flag açarken sorulacak üç soru.