Java 21 LTS Yenilikleri: Virtual Threads, Pattern Matching ve Daha Fazlası (2025)

Java LTS Sürüm Geçmişi (LTS Version History)

• Java 8 (2014) - Lambdas, Streams
• Java 11 (2018) - HTTP Client, var keyword
• Java 17 (2021) - Sealed Classes, Pattern Matching
• Java 21 (2023) - Virtual Threads, Pattern Matching Switch ✅
• Java 25 (2025) - Gelecek LTS (next LTS)

Geleneksel Platform Threads vs Virtual Threads

❌ Eski Yöntem (Platform Threads):

// Platform thread oluşturma (costly!)
Thread thread = new Thread(() -> {
    // Görev (task)
});
thread.start();

// Problem: Her thread ~1MB hafıza kullanır (each thread uses ~1MB memory)
// Maximum ~10,000 thread oluşturabilirsiniz

✅ Yeni Yöntem (Virtual Threads - Java 21):

// Virtual thread oluşturma (cheap!)
Thread vThread = Thread.ofVirtual().start(() -> {
    // Görev
});

// Virtual thread sadece ~1KB kullanır!
// Milyonlarca virtual thread oluşturabilirsiniz (millions possible)!

Gerçek Dünya Örneği: HTTP Server (Real World Example)

import java.util.concurrent.*;

public class VirtualThreadsDemo {
    public static void main(String[] args) throws Exception {
        // Virtual Thread Executor oluştur (create virtual thread executor)
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {

            // 1 milyon task submit et! (submit 1 million tasks!)
            for (int i = 0; i < 1_000_000; i++) {
                int taskId = i;
                executor.submit(() -> {
                    System.out.println("Task " + taskId + " çalışıyor (running)");
                    try {
                        Thread.sleep(1000);  // Blocking I/O simulation
                    } catch (InterruptedException e) {}
                });
            }
        }  // Executor otomatik kapanır (auto-closes)

        System.out.println("1 milyon virtual thread çalıştı! (1M virtual threads ran!)");
    }
}

Sonuç (Result): Geleneksel threadlerle bu imkansız olurdu (impossible with platform threads)! Virtual threads ile sorunsuz çalışır.

Spring Boot ile Virtual Threads (with Spring Boot)

# application.properties
spring.threads.virtual.enabled=true

# Hepsi bu! (That's it!)
# Spring Boot otomatik olarak virtual threads kullanır (auto-uses virtual threads)

Alesta Web ekibi Spring Boot projelerinde virtual threads ile %300 performans artışı gördü (saw 300% performance increase)!

Eski Yöntem (Old Way):

// ❌ Karmaşık ve tekrarlayan (complex and repetitive)
Object obj = getObject();

if (obj instanceof String) {
    String s = (String) obj;
    System.out.println("String uzunluğu: " + s.length());
} else if (obj instanceof Integer) {
    Integer i = (Integer) obj;
    System.out.println("Integer değer: " + i);
} else if (obj instanceof Double) {
    Double d = (Double) obj;
    System.out.println("Double değer: " + d);
} else {
    System.out.println("Bilinmeyen tip (unknown type)");
}

Yeni Yöntem (New Way - Java 21):

// ✅ Temiz ve okunabilir (clean and readable)
Object obj = getObject();

switch (obj) {
    case String s  -> System.out.println("String uzunluğu: " + s.length());
    case Integer i -> System.out.println("Integer değer: " + i);
    case Double d  -> System.out.println("Double değer: " + d);
    case null      -> System.out.println("Null değer (null value)");
    default        -> System.out.println("Bilinmeyen tip");
}

Avantajlar: %50 daha az kod (50% less code), tip güvenliği (type safety), okunabilirlik (readability).

Guards ile İleri Düzey (Advanced with Guards):

switch (obj) {
    case String s when s.length() > 10 ->
        System.out.println("Uzun string: " + s);
    case String s ->
        System.out.println("Kısa string: " + s);
    case Integer i when i > 0 ->
        System.out.println("Pozitif sayı (positive number): " + i);
    case Integer i ->
        System.out.println("Negatif veya sıfır (negative or zero): " + i);
    default -> System.out.println("Diğer (other)");
}

when clause ile ek koşullar ekleyebilirsiniz (add extra conditions with when clause)!

Record Tanımı (Record Definition):

// Record oluştur (create record)
record Point(int x, int y) {}

record Circle(Point center, int radius) {}

record Rectangle(Point topLeft, Point bottomRight) {}

Eski Yöntem (Old Way):

// ❌ Manuel alan çıkarma (manual field extraction)
void printShape(Object shape) {
    if (shape instanceof Circle) {
        Circle c = (Circle) shape;
        Point center = c.center();
        int x = center.x();
        int y = center.y();
        System.out.println("Circle merkez: (" + x + ", " + y + ")");
    }
}

Yeni Yöntem (New Way - Java 21):

// ✅ Record Pattern ile doğrudan parçala (deconstruct directly)
void printShape(Object shape) {
    switch (shape) {
        case Circle(Point(int x, int y), int radius) ->
            System.out.println("Circle merkez: (" + x + ", " + y + "), yarıçap: " + radius);

        case Rectangle(Point(int x1, int y1), Point(int x2, int y2)) ->
            System.out.println("Rectangle köşeler: (" + x1 + "," + y1 + ") - (" + x2 + "," + y2 + ")");

        default ->
            System.out.println("Bilinmeyen şekil (unknown shape)");
    }
}

Alesta Web ekibi bu özelliği DTOları (Data Transfer Objects) işlerken çok kullanıyor (uses this feature extensively when processing DTOs)!

Yeni Interface'ler (New Interfaces):

// Yeni interface hiyerarşisi (new interface hierarchy)
interface SequencedCollection<E> extends Collection<E> {
    SequencedCollection<E> reversed();  // Ters sıra (reverse order)
    void addFirst(E e);                  // Başa ekle (add to beginning)
    void addLast(E e);                   // Sona ekle (add to end)
    E getFirst();                        // İlk eleman (first element)
    E getLast();                         // Son eleman (last element)
    E removeFirst();                     // İlk elemanı sil (remove first)
    E removeLast();                      // Son elemanı sil (remove last)
}

Eski Yöntem (Old Way):

// ❌ Her koleksiyon tipi için farklı yöntem (different method for each type)
List<String> list = new ArrayList<>();
String first = list.get(0);           // List için
String last = list.get(list.size() - 1);

LinkedList<String> linkedList = new LinkedList<>();
String first2 = linkedList.getFirst();  // LinkedList için farklı!

Deque<String> deque = new ArrayDeque<>();
String first3 = deque.peekFirst();      // Deque için başka!

Yeni Yöntem (New Way - Java 21):

// ✅ Tüm koleksiyonlarda aynı API! (same API for all collections!)
List<String> list = new ArrayList<>();
list.addFirst("İlk (First)");
list.addLast("Son (Last)");

String first = list.getFirst();  // Tüm sequenced collections için çalışır!
String last = list.getLast();

// Ters sıra (reverse order)
List<String> reversed = list.reversed();

// LinkedHashMap, LinkedHashSet de destekler!
LinkedHashSet<String> set = new LinkedHashSet<>();
set.addFirst("A");
set.addLast("Z");

Sonuç: Tutarlı API, daha az hata (consistent API, fewer errors)!

Eski Yöntem (Old Way):

// ❌ String birleştirme karmaşık (string concatenation complex)
String name = "Ahmet";
int age = 25;
String message = "Merhaba " + name + ", yaşınız " + age;

// String.format - verbose
String message2 = String.format("Merhaba %s, yaşınız %d", name, age);

Yeni Yöntem (New Way - Java 21 Preview):

// ✅ String Template (clean and safe)
String name = "Ahmet";
int age = 25;
String message = STR."Merhaba \{name}, yaşınız \{age}";

// SQL Template (SQL injection prevention)
String query = STR."""
    SELECT * FROM users
    WHERE name = \{name}
    AND age > \{age}
    """;

// Otomatik escaping! (auto-escaping!)

Not: Preview özellik olduğu için --enable-preview flag'i gereklidir (requires --enable-preview flag).

1. Generational ZGC (Garbage Collector)

Düşük gecikmeli (low-latency) garbage collection daha da iyileşti. Büyük heap'ler için mükemmel (perfect for large heaps):

java -XX:+UseZGC -XX:+ZGenerational MyApp

2. Key Encapsulation Mechanism API (KEM)

Kuantum sonrası şifreleme için (for post-quantum cryptography) hazırlık:

import javax.crypto.KEM;

// KEM API kullanımı (using KEM API)
KEM kem = KEM.getInstance("DHKEM");
// Kuantum-güvenli şifreleme (quantum-safe encryption)

3. Foreign Function & Memory API (FFM)

C/C++ kütüphanelerini JNI olmadan kullanın (use C/C++ libraries without JNI):

import java.lang.foreign.*;

// C fonksiyonunu doğrudan çağır (call C function directly)
MemorySegment segment = Arena.ofAuto().allocate(100);
// JNI karmaşası yok! (no JNI complexity!)

Adım 1: Java 21 Kurulumu (Install Java 21)

# SDKMAN ile (with SDKMAN)
sdk install java 21-open

# Windows: Oracle JDK 21 veya Temurin JDK 21 indir
# https://adoptium.net/temurin/releases/?version=21

# Versiyon kontrol (version check)
java -version
# Output: openjdk version "21"

Adım 2: Build Tool Güncellemesi (Update Build Tools)

Maven (pom.xml):

<properties>
    <maven.compiler.source>21</maven.compiler.source>
    <maven.compiler.target>21</maven.compiler.target>
</properties>

Gradle (build.gradle):

java {
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

Adım 3: Dependency Güncellemeleri (Update Dependencies)

<!-- Spring Boot 3.2+ Java 21 destekler (supports Java 21) -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<!-- Virtual Threads aktif et (enable virtual threads) -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Adım 4: Test ve Optimize (Test and Optimize)

1. Tüm testleri çalıştır (run all tests)
2. Deprecated API kullanımlarını bul ve değiştir (find and replace deprecated APIs)
3. Virtual Threads ile performans test et (test performance with virtual threads)
4. Pattern Matching ile kodu modernize et (modernize code with pattern matching)