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.

  1. İki thread de bakiyeyi okuyor ve 100 görüyor.
  2. İkisi de “yeterli” deyip onaylıyor.
  3. İ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: main metodunu (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!
ZamanMain threadİşçi 1 / 2 / 3
t0Döngüyle 3 işi havuza atarHenüz bir şey yok
t1sleep(1000) ile bekler“hazırım” yazar, start.await() ile donar
t2start.countDown()Hâlâ donuk
t3shutdown()Kapı açıldı, üçü birden koşar

İpucu: println‘lere Thread.currentThread().getName() eklerseniz main kısmında main, işçilerde pool-1-thread-1 gibi 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:

LatchBaşlangıçKim countDown yaparKim await ederAmacı
ready100Her workerMain“100 thread de hazır mı?”
start1MainHer worker“Başla” düdüğü
done100Her workerMain“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ış#

  1. Latch’ler kurulur: 100, 1, 100.
  2. Main 100 task’ı havuza atar. Thread’ler hazır oldukça birer birer başlar, aynı anda değil.
  3. Worker: ready.countDown() — “Ben hazırım.” Sayaç 100’den aşağı iner.
  4. Worker: start.await() — Thread burada durur. start 1 olduğu için kimse geçemez; erken gelenler geç gelenleri bekler.
  5. Main: ready.await() — 100 thread’in hepsi kapıya gelene kadar bekler.
  6. Main: start.countDown() — Kapı açılır, 100 thread aynı anda serbest kalır ve register(...) neredeyse eşzamanlı çağrılır. Race’i tetikleme ihtimalinin en yüksek olduğu an.
  7. Worker: finally { done.countDown(); } — Exception olsa bile sayaç düşmeli. Yoksa main sonsuza kadar bekler.
  8. 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:

ZamanMainİşçi 1İşçi 2İşçi 3
t03 işi havuza atarbaşlıyorhenüz başlamadıhenüz başlamadı
t1start.countDown()bekliyordu, geçer––
t2–çalışıyoryeni geldi, kapı açık, beklemeden geçer–
t3–bitti bileçalışıyoryeni 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. execute içinde fırlayan exception sadece loglanır, test görmez. submit kullanıp Future.get() çağırın ya da hataları bir ConcurrentLinkedQueue‘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() yerine await(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.
  • CountDownLatch ile thread’leri bir kapıda toplayıp tek seferde bırakmak, race condition’ı yakalamanın standart yoludur.
  • ready herkesin hazır olmasını, start aynı anda başlamayı, done herkesin bitmesini garanti eder.