Ana Sayfa / Concurrency / Sanal iş parçacıklarıyla eşzamanlı HTTP
Concurrency Orta

Sanal iş parçacıklarıyla eşzamanlı HTTP

Sanal iş parçacıkları ve HttpClient ile birçok URL'yi eşzamanlı getirin.

Kod Karşılaştırması
✕ Java 8 
ExecutorService pool =
    Executors.newFixedThreadPool(10);
List<Future<String>> futures =
    urls.stream()
    .map(u -> pool.submit(
        () -> fetchUrl(u)))
    .toList();
// manual shutdown, blocking get()
✓ Java 21+ 
try (var exec = Executors
    .newVirtualThreadPerTaskExecutor()) {
    var results = urls.stream()
        .map(u -> exec.submit(
            () -> client.send(req(u),
                ofString()).body()))
        .toList().stream()
        .map(Future::join).toList();
}
Bu kodda bir sorun mu gördünüz? Bize bildirin.
Modern yöntem neden daha iyi
♾️

İstek başına iş parçacığı

Havuz boyutlandırması yok — URL başına bir sanal iş parçacığı.

📖

Basit kod

Anlaşılır bloklama kodu yazın.

⚡

Yüksek verim

Minimum kaynak kullanımıyla binlerce eşzamanlı istek.

Eski Yaklaşım
İş Parçacığı Havuzu + URLConnection
Modern Yaklaşım
Sanal İş Parçacıkları + HttpClient
JDK'dan itibaren
21
Zorluk
Orta
JDK Desteği
Sanal iş parçacıklarıyla eşzamanlı HTTP
Mevcut

JDK 21 LTS'den itibaren geniş çapta kullanılabilir (Eylül 2023)

Nasıl çalışır

Sanal iş parçacıkları, her HTTP isteği için bir iş parçacığı oluşturmayı pratik hale getirir. HttpClient ile birleştirildiğinde, karmaşık asenkron geri arama kalıplarının yerini ölçeklenen basit bloklama koduyla alır.

İlgili Belgeler
Virtual Threads (JEP 444) ↗ HttpClient ↗
İlgili desenler
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

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

Lock-free lazy initialization

Java 8
class Config {
    private static volatile Config inst;
    static Config get() {
        if (inst == null) {
            synchronized (Config.class) {
                if (inst == null)
                    inst = load();
            }
        }
        return inst;
    }
}
Java 25 (Preview)
class Config {
    private static final
        StableValue<Config> INST =
            StableValue.of(Config::load);

    static Config get() {
        return INST.get();
    }
}
Modernini görmek için üzerine gel ➜
JDK 25+ →
Paylaş 𝕏 🦋 in ⬡