Ana Sayfa / Concurrency / CompletableFuture zinciri
Concurrency Orta

CompletableFuture zinciri

CompletableFuture kullanarak bloklamadan asenkron işlemleri zincirleme.

Kod Karşılaştırması
✕ Pre-Java 8 
Future<String> future =
    executor.submit(this::fetchData);
String data = future.get(); // blocks
String result = transform(data);
✓ Java 8+ 
CompletableFuture.supplyAsync(
    this::fetchData
)
.thenApply(this::transform)
.thenAccept(IO::println);
Bu kodda bir sorun mu gördünüz? Bize bildirin.
Modern yöntem neden daha iyi
🔗

Zincirlenebilir

Asenkron adımları okunabilir bir hatta birleştirin.

🚫

Bloklama yok

Hiçbir iş parçacığı sonuçları beklemek için boşta durmaz.

🛡️

Hata işleme

exceptionally() ve handle() ile temiz hata kurtarma.

Eski Yaklaşım
Bloklayan Future.get()
Modern Yaklaşım
CompletableFuture
JDK'dan itibaren
8
Zorluk
Orta
JDK Desteği
CompletableFuture zinciri
Mevcut

JDK 8'den itibaren geniş çapta kullanılabilir (Mart 2014)

Nasıl çalışır

CompletableFuture, bloklamayan asenkron hatlar sağlar. İşlemleri thenApply, thenCompose, thenAccept ile zincirleyin. Hataları exceptionally() ile işleyin. Birden fazla future'ı allOf/anyOf ile birleştirin.

İlgili Belgeler
CompletableFuture ↗
İlgili desenler
Concurrency İleri

Stable values

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();
}
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+ →
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+ →
Paylaş 𝕏 🦋 in ⬡