Strona główna / Concurrency / Równoległe HTTP z wątkami wirtualnymi
Concurrency Średniozaawansowany

Równoległe HTTP z wątkami wirtualnymi

Pobieraj wiele URL-i równolegle za pomocą wątków wirtualnych i HttpClient.

Porównanie kodu
✕ 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();
}
Widzisz problem z tym kodem? Daj nam znać.
Dlaczego nowoczesne podejście wygrywa
♾️

Jeden wątek na żądanie

Bez dobierania rozmiaru puli — jeden wątek wirtualny na URL.

📖

Prosty kod

Pisz bezpośredni, blokowalny kod.

⚡

Wysoka przepustowość

Tysiące równoległych żądań przy minimalnych zasobach.

Stare podejście
Pula wątków + URLConnection
Nowoczesne podejście
Wątki wirtualne + HttpClient
Od JDK
21
Poziom trudności
Średniozaawansowany
Wsparcie JDK
Równoległe HTTP z wątkami wirtualnymi
Dostępne

Szeroko dostępne od JDK 21 LTS (wrzesień 2023)

Jak to działa

Wątki wirtualne sprawiają, że tworzenie jednego wątku na żądanie HTTP jest praktyczne. W połączeniu z HttpClient zastępuje złożone wzorce asynchronicznych callbacków prostym blokowalnym kodem, który dobrze skaluje.

Powiązana dokumentacja
Virtual Threads (JEP 444) ↗ HttpClient ↗
Dowód
Zobacz źródło dowodu ↗
Powiązane wzorce
Concurrency Zaawansowany

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());
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Concurrency Zaawansowany

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();
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →
Concurrency Zaawansowany

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();
    }
}
Najedź, aby zobaczyć nową wersję ➜
JDK 25+ →