Ana Sayfa / Concurrency / Kararlı değerler
Concurrency İleri

Kararlı değerler

volatile veya synchronized olmadan iş parçacığı güvenli tembel başlatma.

Kod Karşılaştırması
✕ Java 8 
private volatile Logger logger;
Logger getLogger() {
    if (logger == null) {
        synchronized (this) {
            if (logger == null)
                logger = createLogger();
        }
    }
    return logger;
}
✓ Java 25 (Preview) 
private final StableValue<Logger> logger =
    StableValue.of(this::createLogger);

Logger getLogger() {
    return logger.get();
}
Bu kodda bir sorun mu gördünüz? Bize bildirin.
Modern yöntem neden daha iyi
🧹

Sıfır şablonsuz kod

volatile, synchronized veya null kontrolleri yok.

⚡

JVM-optimize

JVM başlatma sonrasında değeri katlayabilir.

🛡️

Bir kez garantili

Sağlayıcı, çakışma altında bile yalnızca bir kez çalışır.

Eski Yaklaşım
Çift Kontrollü Kilitleme
Modern Yaklaşım
StableValue
JDK'dan itibaren
25
Zorluk
İleri
JDK Desteği
Kararlı değerler
Önizleme

JDK 25'te önizleme (JEP 502). --enable-preview gerektirir.

Nasıl çalışır

StableValue, yerleşik iş parçacığı güvenliğiyle tembel başlatılmış, değiştirilemez bir değer sağlar. Çift kontrollü kilitleme yok, volatile alan yok, synchronized blok yok. JVM başlatma sonrasında okuma yolunu bile optimize edebilir.

İlgili Belgeler
Stable Values (JEP 502) ↗ StableValue ↗
İlgili desenler
Concurrency Başlangıç

Virtual threads

Java 8
Thread thread = new Thread(() -> {
    System.out.println("hello");
});
thread.start();
thread.join();
Java 21+
Thread.startVirtualThread(() -> {
    IO.println("hello");
}).join();
Modernini görmek için üzerine gel ➜
JDK 21+ →
Concurrency İleri

Structured concurrency

Java 8
ExecutorService exec =
    Executors.newFixedThreadPool(2);
Future<User> u = exec.submit(this::fetchUser);
Future<Order> o = exec.submit(this::fetchOrder);
try {
    return combine(u.get(), o.get());
} finally { exec.shutdown(); }
Java 25 (Preview)
try (var scope = new StructuredTaskScope
        .ShutdownOnFailure()) {
    var u = scope.fork(this::fetchUser);
    var o = scope.fork(this::fetchOrder);
    scope.join().throwIfFailed();
    return combine(u.get(), o.get());
}
Modernini görmek için üzerine gel ➜
JDK 25+ →
Concurrency İleri

Scoped values

Java 8
static final ThreadLocal<User> CURRENT =
    new ThreadLocal<>();
void handle(Request req) {
    CURRENT.set(authenticate(req));
    try { process(); }
    finally { CURRENT.remove(); }
}
Java 25
static final ScopedValue<User> CURRENT =
    ScopedValue.newInstance();
void handle(Request req) {
    ScopedValue.where(CURRENT,
        authenticate(req)
    ).run(this::process);
}
Modernini görmek için üzerine gel ➜
JDK 25+ →
Paylaş 𝕏 🦋 in ⬡