· 6 dk okuma
Önce Bak, Sonra Yaz: Eş Zamanlı İsteklerde Yarış Durumu
Bir koltuğu satmadan önce boş mu diye bakmak, bir teklife karar yazmadan önce teklifin hâlâ beklediğini kontrol etmek doğal görünür. Bu kalıbın adı check-then-act, yani önce bak, sonra yaz. Tek kullanıcıyla hep doğru çalışır. İki istek aynı anda geldiğinde ise ikisi de "boş" görür ve ikisi de yazar. Bu yazıda bu yarış durumunu (race condition) iki projemde nasıl ele aldığımı anlatıyorum: havayolu rezervasyon sisteminde kısmi bir UNIQUE indeksle, teknik servis uygulaması Tamirhane'de ise PostgreSQL'in satır sürümüyle (iyimser kilit).
Yarış nasıl oluşur?
Koltuk satışının sırası şöyle:
- 17C koltuğu dolu mu? Veritabanına bak.
- Doluysa hata ver, değilse bileti yaz.
İki istek bu adımları aynı anda çalıştırınca:
| Zaman | İstek A | İstek B |
|---|---|---|
| 1 | 17C dolu mu? Hayır. | |
| 2 | 17C dolu mu? Hayır. | |
| 3 | Bileti yaz. | |
| 4 | Bileti yaz. |
Kontrol doğru yapıldı, ama A'nın kontrolü ile yazması arasına B girdi. Sonuç: aynı koltukta iki yolcu. Kodu ne kadar dikkatli yazarsam yazayım, bu iki adım arasında geçen süre sıfır olmadığı sürece yarış mümkün.
Kalıcı çözüm, kuralı yazma anında, tek bir atomik adımda uygulamak. Bunun için veritabanının kendi araçları var.
Havayolu: kısmi UNIQUE indeks
Havayolu rezervasyon sistemim bir masaüstü uygulaması; veritabanı SQLite. Koltuk satışında önce dolu koltuklar okunuyor, seçilen koltuk doluysa anlaşılır bir hata veriliyor:
final Set<String> taken = FlightService.occupied(c, flight.id());
// ...
if (taken.contains(seat.code()))
throw new AirlineException("seatTaken", seat.code());
Bu kontrol kullanıcıya iyi bir mesaj vermek için var. Asıl kural veritabanında:
-- Aynı uçuşta bir koltuk sadece bir geçerli bilette olabilir: çift satışı veritabanı da engeller.
-- İptal edilen biletler (active = 0) indekse girmez, koltuk yeniden satılabilir.
CREATE UNIQUE INDEX IF NOT EXISTS tickets_seat ON tickets(flight_id, seat) WHERE active = 1
Burada iki karar var.
Neden kısmi indeks? Düz bir UNIQUE(flight_id, seat) iptal edilen bileti de sayar ve o koltuk bir daha satılamaz. WHERE active = 1 ile indeks sadece geçerli biletleri kapsıyor; bilet iptal edilince koltuk boşalıyor.
Kontrol varken neden indeks? Bu uygulamada yazma işlemleri tek bir bağlantı üzerinden ve synchronized bir metotla yapılıyor; yani aynı uygulamanın içinde iki satış iç içe giremiyor. Ama bu güvence uygulama koduna bağlı. Koltuk değiştirme gibi koltuğa dokunan başka bir yol, ileride veritabanını açan ikinci bir program ya da kilitsiz yazılmış yeni bir özellik bu korumanın dışında kalır. Kural verinin yanında durursa hangi yoldan gelinirse gelinsin geçerli olur.
İndeks ihlal edilirse veritabanı hata veriyor; servis bunu yakalayıp kullanıcıya teknik bir mesaj yerine "bu koltuk az önce satıldı" diyor:
} catch (DataException e) {
// Aynı koltuğu aynı anda başka bir işlem almışsa veritabanının UNIQUE indeksi engeller
if (e.isUniqueViolation())
throw new AirlineException("seatJustTaken");
throw e;
}
Testi gerçekten aynı anda çalışan isteklerle yazdım. 16 iş parçacığı aynı koltuğu almak için bir kapıda bekliyor, kapı açılınca hepsi birden deniyor ve sadece birinin başarılı olması bekleniyor:
final CountDownLatch start = new CountDownLatch(1);
for (int i = 0; i < 16; i++) {
results.add(pool.submit(() -> {
start.await();
try {
airline.bookings().book(/* aynı uçuş, 17C */);
return true;
} catch (AirlineException e) {
return false;
}
}));
}
start.countDown();
// ...
assertEquals(1, ok);
Tamirhane: satır sürümüyle iyimser kilit
Tamirhane bir web uygulaması; PostgreSQL üzerinde çalışıyor ve her istek kendi veritabanı bağlamını açıyor. Burada uygulama içi bir kilit işe yaramaz: aynı anda gelen iki istek ayrı ayrı çalışıyor, ileride sunucu sayısı da artabilir.
Yarışın yaşanabileceği yer, müşterinin takip sayfasındaki teklif onayıydı. Müşteri "Onarımı onayla"ya iki kez basarsa, ya da bir sekmede onaylayıp diğerinde reddederse, iki istek iş emrini aynı anda okuyor. İkisi de durumu "onay bekliyor" görüyor ve ikisi de karar yazıyor. Geçmişe iki karar düşüyor, iş emri yanlış durumda kalabiliyor.
Burada UNIQUE indeks doğal bir çözüm değil, çünkü korunması gereken şey tek bir sütun değil, iş emrinin bütün durumu. Seçenekler:
- Kötümser kilit: Okurken satırı kilitlemek (
SELECT ... FOR UPDATE). Doğru çalışır, ama her okumada kilit tutmak ve kilidi işlem bitene kadar taşımak gerekir. - İyimser kilit: Kilit yok. Yazarken "okuduğum sürüm hâlâ aynı mı?" diye bakılır; değiştiyse yazma reddedilir.
Çakışmanın nadir olduğu bir durumda iyimser kilit daha uygun. PostgreSQL'de her satırın xmin adında bir sistem sütunu var: satırı son değiştiren işlemin kimliği. Satır her güncellendiğinde değişiyor, yani hazır bir satır sürümü. EF Core'da bunu sürüm sütunu olarak tanıtmak tek satır:
// Satır sürümü (PostgreSQL'in xmin sistem sütunu): durum değişikliği aynı anda iki kez kaydedilemez
// (ör. müşteri teklif onayına çift tıklarsa ikinci istek "değişmiş" hatası alır).
b.Property<uint>("Version").IsRowVersion();
Bundan sonra EF Core iş emrini güncellerken WHERE koşuluna okuduğu sürümü de ekliyor. Arada başka bir istek satırı değiştirdiyse sürüm tutmuyor, güncelleme 0 satırı etkiliyor ve EF Core DbUpdateConcurrencyException fırlatıyor.
Clean Architecture'da uygulama katmanı EF Core'u tanımıyor. Bu yüzden altyapı katmanı hatayı kendi tipine çeviriyor:
async Task IUnitOfWork.SaveChangesAsync(CancellationToken ct)
{
try
{
await SaveChangesAsync(ct);
}
catch (DbUpdateConcurrencyException e)
{
throw new ConcurrencyConflictException(e);
}
}
Kullanım senaryosu da bunu bir sonuca çeviriyor; kullanıcı 500 hatası değil, anlaşılır bir mesaj görüyor:
try
{
await unitOfWork.SaveChangesAsync(ct);
}
catch (ConcurrencyConflictException)
{
return ApplicationErrors.ConcurrentChange;
}
Takip sayfasında bu durumda "Bu teklif için karar zaten verilmiş; sayfadaki son durum geçerli" yazıyor. Düğmeler de gönderimden sonra kilitleniyor, ama o sadece kolaylık; asıl koruma veritabanında.
Test, iki isteğin aynı anda okuduğu anı iki ayrı veritabanı bağlamıyla gerçek PostgreSQL üzerinde canlandırıyor:
// İki istek iş emrini aynı anda okur; ikisi de "onay bekliyor" görür.
var a = (await first.Orders.GetByTrackingCodeAsync(code, default))!;
var b = (await second.Orders.GetByTrackingCodeAsync(code, default))!;
Assert.True(a.DecideQuote(true, "Ayşe Kaya", null, Now).IsSuccess);
await first.UnitOfWork.SaveChangesAsync(default);
Assert.True(b.DecideQuote(false, "Ayşe Kaya", null, Now).IsSuccess);
await Assert.ThrowsAsync<ConcurrencyConflictException>(() => second.UnitOfWork.SaveChangesAsync(default));
Bu test, zamanlamaya bırakılmış bir yarış değil. İç içe geçme adım adım yazıldığı için her çalıştırmada aynı sonucu veriyor.
İki çözümün farkı
| Kısmi UNIQUE indeks | Satır sürümü (iyimser kilit) | |
|---|---|---|
| Neyi korur? | Tek bir kural: bir koltuk bir bilet | Bir kaydın bütün durumu |
| Çakışmada | Ekleme reddedilir | Güncelleme reddedilir |
| Uygun olduğu yer | Kural bir sütun kombinasyonuyla ifade edilebiliyorsa | Kural birden çok alana ve iş mantığına yayılıyorsa |
Üçüncü bir örnek de Casus'ta var: oda kodu Redis'e "anahtar yoksa yaz" kuralıyla tek komutta kaydediliyor. Mantık aynı: kontrol ve yazma tek bir atomik adım.
Öğrendiklerim
- Önce bak, sonra yaz her zaman yarışa açık. Kontrol kullanıcıya iyi bir mesaj vermek için kalabilir, ama kuralın kendisi yazma anında, atomik olarak uygulanmalı.
- Kuralı verinin yanına koymak onu uygulamanın her yolunda geçerli kılıyor: UNIQUE ya da kısmi indeks, satır sürümü, Redis'te "yoksa yaz".
- Uygulama içi kilit tek sürece güvenir. Masaüstünde yeterli olabilir; web'de istekler ayrı bağlamlarda ve ileride ayrı sunucularda çalışır.
- Yarışı test etmenin iki yolu var: gerçekten aynı anda başlatılan iş parçacıkları ya da iç içe geçmeyi adım adım yazan deterministik bir test. İkincisi hiç sebepsiz düşmüyor.