Race Condition'ı Test Etmek: CountDownLatch ile 100 Thread'i Aynı Anda Başlatmak
Eşzamanlılık hatalarını yakalamak zordur, çünkü çoğu zaman sadece “doğru” zamanlamada ortaya çıkarlar. Bu yazıda race condition’ın ne olduğunu, bunu test ederken sık yapılan bir hatayı ve CountDownLatch ile thread’leri gerçekten aynı anda nasıl başlatabileceğimizi adım adım anlatacağım.
Race Condition Nedir?#
Race condition, iki ya da daha fazla işlem aynı paylaşılan veriye neredeyse aynı anda eriştiğinde ortaya çıkar. Sonuç, işlemlerin hangi sırayla çalıştığına göre değişir ve bu sıra her seferinde farklı olabilir.
Ödeme dünyasından bir örnek: Kartta 100 TL limit kaldı ve aynı anda 80 TL’lik iki provizyon geliyor.
- İki thread de bakiyeyi okuyor ve 100 görüyor.
- İkisi de “yeterli” deyip onaylıyor.
- İkisi de bakiyeyi 20’ye yazıyor.
Sonuçta 160 TL harcanmış oluyor ama sistem 20 TL kaldığını sanıyor. Sorun, okuma → kontrol → yazma adımlarının tek ve bölünmez (atomik) bir işlem olarak yapılmaması.
Yaygın çözümler:
- Pessimistic locking: Veritabanında satırı kilitlemek (
SELECT ... FOR UPDATE). - Optimistic locking: Versiyon kolonu ile çakışmayı yazma anında tespit etmek.
- Atomik sorgu:
UPDATE card SET balance = balance - 80 WHERE id = ? AND balance >= 80 - Tek sıra: Aynı karta gelen mesajları tek bir kuyrukta işlemek (Akka’daki actor modeli bunu yapar).
Yaygın Hata: “100 Thread Açtım” Yanılgısı#
Bir servisin eşzamanlı çağrılara dayanıklı olup olmadığını test etmek istiyoruz. İlk akla gelen kod şu:
ExecutorService executorService = Executors.newFixedThreadPool(100);
executorService.execute(() -> serviceRegistry.register("http://10.0.0.1:8080"));
Bu kod sadece 1 kez çağrı yapar. newFixedThreadPool(100) havuzda 100 thread olabileceğini söyler, ama execute bir kez çağrıldığı için tek bir task gönderilir.
Döngü ekleyerek 100 task gönderebiliriz:
ExecutorService executorService = Executors.newFixedThreadPool(100);
for (int i = 0; i < 100; i++) {
executorService.execute(() -> serviceRegistry.register("http://10.0.0.1:8080"));
}
executorService.shutdown();
executorService.awaitTermination(30, TimeUnit.SECONDS);
Ama bu da yeterli değil. Task’lar sırayla gönderilir ve ilk thread’ler, son task gönderilmeden işini bitirebilir. Çağrılar üst üste binmez, test “race yok” diye yanlış bir güven verir.
Çözüm: CountDownLatch#
CountDownLatch bir sayaçlı kapıdır:
- Bir sayıyla başlar.
countDown()sayacı 1 azaltır.await()çağıran thread’i sayaç 0 olana kadar bekletir.- Sayaç 0’a inince kapı açılır ve bir daha kapanmaz.
Önce Main Thread ve Worker Thread Ayrımı#
Kodu okurken en çok karışan nokta, hangi satırı kimin çalıştırdığıdır:
- Main thread:
mainmetodunu (ya da testi) çalıştıran thread. İşleri dağıtır, düdüğü çalar, sonucu kontrol eder. - Worker thread: Havuzdaki işçiler. Sadece
execute(() -> { ... })içindeki lambda’yı çalıştırırlar.
Basit kural: Lambda’nın
{ }içi worker’a, dışı main’e aittir.execute(...)çağrısını main yapar, ama verdiği kodu worker çalıştırır.
Küçük Örnek: 3 İşçi, 1 Düdük#
public static void main(String[] args) throws Exception {
ExecutorService pool = Executors.newFixedThreadPool(3);
CountDownLatch start = new CountDownLatch(1);
// ===== MAIN: işleri dağıtıyor =====
for (int i = 1; i <= 3; i++) {
int no = i;
pool.execute(() -> {
// ===== WORKER: işçinin kodu =====
System.out.println("İşçi " + no + ": hazırım, düdüğü bekliyorum");
try {
start.await(); // düdük çalana kadar bekle
} catch (InterruptedException e) { return; }
System.out.println("İşçi " + no + ": KOŞUYORUM!");
});
}
// ===== MAIN tekrar devrede =====
Thread.sleep(1000); // işçiler dizilsin diye bekle
System.out.println("Main: düdük çalıyorum!");
start.countDown(); // 1 -> 0, kapı açıldı
pool.shutdown();
}
Örnek çıktı (işçi sırası her çalıştırmada değişebilir):
İşçi 1: hazırım, düdüğü bekliyorum
İşçi 3: hazırım, düdüğü bekliyorum
İşçi 2: hazırım, düdüğü bekliyorum
Main: düdük çalıyorum!
İşçi 2: KOŞUYORUM!
İşçi 1: KOŞUYORUM!
İşçi 3: KOŞUYORUM!
| Zaman | Main thread | İşçi 1 / 2 / 3 |
|---|---|---|
| t0 | Döngüyle 3 işi havuza atar | Henüz bir şey yok |
| t1 | sleep(1000) ile bekler | “hazırım” yazar, start.await() ile donar |
| t2 | start.countDown() | Hâlâ donuk |
| t3 | shutdown() | Kapı açıldı, üçü birden koşar |
İpucu:
println‘lereThread.currentThread().getName()eklerseniz main kısmındamain, işçilerdepool-1-thread-1gibi isimler görürsünüz.
Buradaki Thread.sleep(1000) aslında kaba bir tahmin: “1 saniyede herkes dizilmiş olur herhalde.” Gerçek testte bunu garantiye bağlamak gerekir.
Tam Versiyon: Üç Latch#
int threadCount = 100;
ExecutorService executorService = Executors.newFixedThreadPool(threadCount);
CountDownLatch ready = new CountDownLatch(threadCount);
CountDownLatch start = new CountDownLatch(1);
CountDownLatch done = new CountDownLatch(threadCount);
for (int i = 0; i < threadCount; i++) {
executorService.execute(() -> {
ready.countDown();
try {
start.await(); // herkes burada bekler
serviceRegistry.register("http://10.0.0.1:8080");
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
done.countDown();
}
});
}
ready.await(); // 100 thread de hazır
start.countDown(); // hepsini aynı anda bırak
done.await(); // hepsi bitsin
executorService.shutdown();
// Assert: register idempotent olmalıysa kayıt sayısı 1 olmalı
Her latch’in ayrı bir görevi var:
| Latch | Başlangıç | Kim countDown yapar | Kim await eder | Amacı |
|---|---|---|---|---|
ready | 100 | Her worker | Main | “100 thread de hazır mı?” |
start | 1 | Main | Her worker | “Başla” düdüğü |
done | 100 | Her worker | Main | “Herkes bitirdi mi?” |
Bir koşu yarışı gibi düşünün: ready atletlerin çizgiye dizilmesi, start hakemin silahı, done herkesin bitiş çizgisini geçmesi.
Adım Adım Akış#
- Latch’ler kurulur: 100, 1, 100.
- Main 100 task’ı havuza atar. Thread’ler hazır oldukça birer birer başlar, aynı anda değil.
- Worker:
ready.countDown()— “Ben hazırım.” Sayaç 100’den aşağı iner. - Worker:
start.await()— Thread burada durur.start1 olduğu için kimse geçemez; erken gelenler geç gelenleri bekler. - Main:
ready.await()— 100 thread’in hepsi kapıya gelene kadar bekler. - Main:
start.countDown()— Kapı açılır, 100 thread aynı anda serbest kalır veregister(...)neredeyse eşzamanlı çağrılır. Race’i tetikleme ihtimalinin en yüksek olduğu an. - Worker:
finally { done.countDown(); }— Exception olsa bile sayaç düşmeli. Yoksa main sonsuza kadar bekler. - Main:
done.await()— Tüm çağrılar bitince assert güvenle yapılabilir.
InterruptedException catch’i: await() beklerken thread kesilirse bu exception fırlar. Thread.currentThread().interrupt() ile kesilme bilgisi geri işaretlenir, böylece bilgi kaybolmaz.
ready.await() Olmazsa Ne Olur?#
Test yine çalışır, kilitlenmez. Ama main düdüğü erken çalabilir. Henüz kapıya gelmemiş işçiler sonradan geldiğinde kapıyı açık bulur ve beklemeden geçer:
| Zaman | Main | İşçi 1 | İşçi 2 | İşçi 3 |
|---|---|---|---|---|
| t0 | 3 işi havuza atar | başlıyor | henüz başlamadı | henüz başlamadı |
| t1 | start.countDown() | bekliyordu, geçer | – | – |
| t2 | – | çalışıyor | yeni geldi, kapı açık, beklemeden geçer | – |
| t3 | – | bitti bile | çalışıyor | yeni geldi, geçer |
İşçi 1 işini bitirmişken İşçi 3 daha başlamamış olabilir. Çağrılar çakışmaz ve test yanlış bir güven verir. ready.await(), küçük örnekteki sleep‘in yaptığı işi tahmin yerine garantiyle yapar.
Küçük bir not: ready.await() bile kusursuz eşzamanlılık sağlamaz; countDown() ile start.await() arasında çok kısa bir an geçer. Pratikte bu ihmal edilebilir ve bu kalıp race testleri için standart kabul edilir.
Pratik İpuçları#
- Exception’lar kaybolabilir.
executeiçinde fırlayan exception sadece loglanır, test görmez.submitkullanıpFuture.get()çağırın ya da hataları birConcurrentLinkedQueue‘ya toplayın. - Sonucu doğrulayın. Asıl soru: “Aynı URL 100 kez register edildiğinde registry’de tek kayıt mı var?”
- Timeout kullanın.
await()yerineawait(10, TimeUnit.SECONDS)tercih edin; bir şey takılırsa test sonsuza kadar asılı kalmaz. - Testi tekrarlayın. Race’ler her çalıştırmada ortaya çıkmaz.
@RepeatedTest(200)gibi tekrarlar bulma ihtimalini artırır.
Özet#
newFixedThreadPool(100)100 çağrı yapmaz; kaç task gönderdiyseniz o kadar çağrı olur.- Döngüyle gönderilen task’lar aynı anda başlamaz.
CountDownLatchile thread’leri bir kapıda toplayıp tek seferde bırakmak, race condition’ı yakalamanın standart yoludur.readyherkesin hazır olmasını,startaynı anda başlamayı,doneherkesin bitmesini garanti eder.