Java 21 Sanal İş Parçacıkları (Virtual Threads): Yüksek Eşzamanlılığa Sade Yol

Sanal iş parçacıkları (virtual threads), Java 21 ile kararlı hale gelen ve yıllardır Project Loom adıyla geliştirilen bir özellik. Tek cümleyle: artık milyonlarca eşzamanlı görevi, klasik thread-per-request modelinin sadeliğiyle ama platform thread’lerinin maliyeti olmadan çalıştırabiliyoruz.

Bu yazıda sanal iş parçacıklarının ne olduğunu, neden önemli olduğunu ve gerçek kodda nasıl kullanıldığını; ayrıca düşmeden önce bilmen gereken tuzakları anlatıyorum. Daha fazla Java içeriği için Java sayfama göz atabilirsin.

Sorun: platform thread’leri pahalı

Klasik bir Java thread’i (platform thread), işletim sisteminin bir thread’ine bire bir karşılık gelir. Her biri ~1 MB yığın (stack) ayırır ve OS tarafından zamanlanır. Bir web sunucusunda “her istek için bir thread” açmak isterdik çünkü kod basit ve okunabilir olur — ama birkaç bin thread’den sonra bellek ve bağlam değiştirme (context switch) maliyeti seni durdurur.

Bu yüzden yıllarca reaktif ve asenkron API’lere kaçtık: CompletableFuture, callback zincirleri, reaktif akışlar… Performanslı ama okuması ve hata ayıklaması zor kod.

Sanal iş parçacığı nedir?

Sanal iş parçacığı, JVM tarafından zamanlanan hafif bir thread’tir. Bir OS thread’ine kalıcı olarak bağlı değildir; yalnızca gerçekten iş yaptığı (CPU kullandığı) anlarda bir taşıyıcı (carrier) platform thread’ine bağlanır. Bir G/Ç çağrısında (ağ, dosya, veritabanı) beklemeye girdiğinde JVM onu taşıyıcıdan ayırır (unmount) ve taşıyıcıyı başka bir sanal thread’e verir.

Sonuç: on binlerce sanal thread, avuç dolusu OS thread’i üzerinde çalışabilir.

flowchart TD
    subgraph JVM
      V1[Sanal thread 1] --> C1[Taşıyıcı thread]
      V2[Sanal thread 2] --> C1
      V3[Sanal thread 3] --> C2[Taşıyıcı thread]
      V4[Sanal thread N] -.G/Ç'de bekliyor.-> P[(Park edildi)]
    end
    C1 --> OS[(OS thread havuzu)]
    C2 --> OS

Nasıl oluşturulur?

En basit haliyle bir sanal thread başlatmak:

1
Thread.startVirtualThread(() -> {
2
    System.out.println("Merhaba, sanal dünya!");
3
});

Gerçek hayatta ise görevleri bir ExecutorService ile yönetirsin. Buradaki kilit nokta: her görev için yeni bir sanal thread açan executor’ı kullanmak.

1
import java.util.concurrent.Executors;
2

3
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
4
    for (int i = 0; i < 10_000; i++) {
5
        int taskId = i;
6
        executor.submit(() -> {
7
            // G/Ç ağırlıklı iş — örn. bir HTTP çağrısı
8
            var result = callRemoteService(taskId);
9
            process(result);
10
        });
11
    }
12
} // executor.close() tüm görevlerin bitmesini bekler

Yukarıdaki 10.000 görev, 10.000 OS thread’i açmadan çalışır. Kod ise tamamen senkron ve okunabilir.

Adım adım: Spring Boot’ta açmak

Spring Boot 3.2+ ile sanal iş parçacıklarını tek satırlık bir ayarla etkinleştirebilirsin:

Ne zaman kullanmalı, ne zaman kaçınmalı?

Dikkat: “pinning” tuzağı

Sanal bir thread, synchronized bir blok içindeyken bir G/Ç çağrısında bloklanırsa, taşıyıcı thread’ine sabitlenir (pinned) ve onu serbest bırakamaz. Çok sayıda pinning, sanal thread’lerin tüm avantajını yok edebilir.

1
synchronized (lock) {
2
    // ❌ Kilit altında uzun G/Ç → pinning
3
    var data = database.query(sql);
4
    cache.put(key, data);
5
}

1
private final ReentrantLock lock = new ReentrantLock();
2

3
// ✓ ReentrantLock pinning'e yol açmaz
4
lock.lock();
5
try {
6
    var data = database.query(sql);
7
    cache.put(key, data);
8
} finally {
9
    lock.unlock();
10
}

Sonuç

Sanal iş parçacıkları, Java’da eşzamanlılığı yıllar sonra yeniden basit yapıyor: senkron kod yaz, yine de yüksek ölçeklen. Anahtar kurallar:

• Görev başına yeni sanal thread aç, havuzlama.
• G/Ç ağırlıklı işlerde kullan; CPU-yoğun işlerde klasik havuzlarda kal.
• synchronized + uzun G/Ç kombinasyonundan kaçın, ReentrantLock kullan.
• Her zaman ölç.

Daha fazlası için #java ve #concurrency etiketlerine, ya da derli toplu Java sayfasına bakabilirsin.