Java Academy · Lekcja

Czym są wirtualne wątki

Lekkie wątki w Javie 21

Czym są wirtualne wątki to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Wprowadzenie do wątków wirtualnych

Wątki wirtualne stały się pełnoprawną funkcją w Java 21 (JEP 444). Są to lekkie wątki zarządzane przez JVM, a nie przez system operacyjny.

Cel jest prosty: umożliwić pisanie przejrzystego kodu w modelu wątek na żądanie, a jednocześnie skalowanie do milionów równoczesnych zadań.

Dotychczasowy problem

Tradycyjny wątek platformowy jest mapowany jeden do jednego na wątek systemu operacyjnego. Każdy zużywa około megabajta pamięci stosu i jest kosztowny w tworzeniu.

Oznacza to, że jednocześnie można uruchomić tylko kilka tysięcy takich wątków. Blokujące operacje wejścia/wyjścia zajmują cały wątek systemu operacyjnego podczas oczekiwania.

Czym różnią się wątki wirtualne

Wątek wirtualny nie posiada własnego wątku systemu operacyjnego. Wiele wątków wirtualnych jest multipleksowanych na niewielkiej puli platformowych wątków nośnikowych.

Tanie w tworzeniu — tysiące w ciągu milisekundy
Niewielkie zużycie pamięci
Blokowanie po prostu wstrzymuje wątek wirtualny, uwalniając wątek nośnikowy

Montowanie i odmontowywanie

Gdy wątek wirtualny działa, jest montowany na wątku nośnikowym. Gdy napotka operację blokującą, zostaje odmontowany, uwalniając wątek nośnikowy, aby inna praca mogła być kontynuowana.

To wstrzymywanie i wznawianie odbywa się automatycznie. Kod wygląda jak zwykły kod z blokowaniem.

Pierwszy wątek wirtualny

Oto najprostszy możliwy przykład. Thread.ofVirtual().start(...) uruchamia wątek wirtualny, a join() czeka na jego zakończenie.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() ->
            System.out.println("Hello from a virtual thread!"));
        vt.join();
        System.out.println("Main is done.");
    }
}

Sprawdzanie, czy wątek jest wirtualny

Każdy obiekt Thread udostępnia metodę isVirtual(). Umożliwia ona sprawdzenie, na jakim rodzaju wątku działa kod.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual().start(() -> {
            System.out.println("isVirtual: " + Thread.currentThread().isVirtual());
        });
        vt.join();
    }
}

Skalowanie do wielu zadań

Ponieważ wątki wirtualne są tanie, uruchamianie dziesiątek tysięcy zadań jest zupełnie normalne. W tym przykładzie uruchamiamy 10 000 takich wątków.

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        AtomicInteger counter = new AtomicInteger();
        Thread[] threads = new Thread[10_000];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = Thread.ofVirtual().start(counter::incrementAndGet);
        }
        for (Thread t : threads) t.join();
        System.out.println("Completed: " + counter.get());
    }
}

Nadawanie nazw wątkom wirtualnym

Możesz nadać wątkowi wirtualnemu nazwę, aby ułatwić debugowanie, korzystając z buildera przed jego uruchomieniem.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread vt = Thread.ofVirtual()
                .name("worker-1")
                .start(() ->
                    System.out.println("Running on: " + Thread.currentThread().getName()));
        vt.join();
    }
}

To samo API, nowy mechanizm

Wątki wirtualne implementują dokładnie to samo API Thread, które już znasz. Nadal używasz metod start, join, sleep i interrupt.

Oznacza to, że istniejące biblioteki oparte na Thread i Runnable działają bez zmian.

Kiedy ich używać

Wątki wirtualne doskonale sprawdzają się w przypadku obciążeń I/O-bound: serwerów internetowych, wywołań baz danych i żądań do zdalnych interfejsów API.

Nie są szybsze w przypadku obciążeń CPU-bound, czyli intensywnych obliczeń numerycznych. W takich sytuacjach nadal ogranicza Państwa liczba rdzeni.

To nie jest pula

Najważniejsza zmiana sposobu myślenia polega na tym, że wątków wirtualnych nie należy umieszczać w puli. Należy tworzyć nowy wątek dla każdego zadania i pozwolić mu zakończyć działanie po jego ukończeniu.

Pule służą do ponownego wykorzystywania kosztownych zasobów. Wątki wirtualne są tanie, więc ich umieszczanie w puli jest antywzorcem.

Szybkie sprawdzenie

Sprawdźmy, czy rozumieją Państwo działanie wątków wirtualnych.

Podsumowanie

Dowiedzieli się Państwo, czym są wątki wirtualne i dlaczego mają znaczenie:

Lekkie, zarządzane przez JVM i sfinalizowane w Java 21
Multipleksowane na wątkach nośnych za pomocą montowania i odmontowywania
Idealne do wysoce współbieżnych zadań I/O-bound
Korzystają z tego samego interfejsu API Thread, ale są tworzone dla poszczególnych zadań, a nie umieszczane w puli

W następnej części poznają Państwo różne sposoby ich tworzenia.

Często zadawane pytania

Czy lekcja „Czym są wirtualne wątki” jest bezpłatna?

Tak — pełny tekst „Czym są wirtualne wątki” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Czym są wirtualne wątki”?

Lekkie wątki w Javie 21 Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Czym są wirtualne wątki”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy