Java Academy · Oppitunti

Virtuaalisäikeiden luonti

Thread.ofVirtual ja suorittimet.

Oppitunti 2/413 vaihetta

Virtuaalisäikeiden luonti on ilmainen Java Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Java Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Java Academy-kurssilla on yhteensä 4 oppituntia.

Virtuaalisäikeiden luomistavat

Java tarjoaa useita tapoja luoda virtuaalisäikeitä. Kaksi tärkeintä ovat Thread.ofVirtual()-rakentaja ja Executors.newVirtualThreadPerTaskExecutor()-tehdas.

Tässä oppitunnissa käydään läpi kumpikin.

Rakentaja: start

Thread.ofVirtual() palauttaa rakentajan. Kutsulla .start(runnable) säie luodaan ja käynnistetään heti.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().start(() ->
            System.out.println("Started directly"));
        t.join();
    }
}

Rakentaja: unstarted

Käyttäkää .unstarted(runnable)-metodia, kun haluatte määrittää säikeen asetukset ja käynnistää sen myöhemmin.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.ofVirtual().unstarted(() ->
            System.out.println("Started later"));
        System.out.println("Before start, alive? " + t.isAlive());
        t.start();
        t.join();
    }
}

Uudelleenkäytettävä tehdas

Rakentaja voi tuottaa ThreadFactory-tehtaan kutsulla .factory(). Jokainen newThread-kutsu palauttaa uuden virtuaalisäikeen.

import java.util.concurrent.ThreadFactory;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ThreadFactory factory = Thread.ofVirtual().name("job-", 0).factory();
        Thread a = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        Thread b = factory.newThread(() ->
            System.out.println(Thread.currentThread().getName()));
        a.start(); b.start();
        a.join(); b.join();
    }
}

Kätevä apumetodi

Thread.startVirtualThread(runnable) on lyhyt tapa luoda ja käynnistää nimeämätön virtuaalisäie yhdellä kutsulla.

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread t = Thread.startVirtualThread(() ->
            System.out.println("One-liner virtual thread"));
        t.join();
    }
}

Executor-lähestymistapa

Tehtäväkeskeisessä koodissa kannattaa käyttää Executors.newVirtualThreadPerTaskExecutor()-metodia. Se luo uuden virtuaalisäikeen jokaista suoritettavaksi annettua tehtävää varten.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            exec.submit(() -> System.out.println("task one"));
            exec.submit(() -> System.out.println("task two"));
        }
        System.out.println("All tasks submitted and completed");
    }
}

Miksi try-with-resources

Java 19:stä lähtien ExecutorService toteuttaa AutoCloseable-rajapinnan. Kun se suljetaan try-with-resources-lohkossa, kaikkien suoritettaviksi annettujen tehtävien valmistumista odotetaan.

Näin saatte hallitun ja siistin sammutuksen ilman manuaalisia shutdown- ja awaitTermination-kutsuja.

Monien tehtävien lähettäminen

Tehtäväkohtainen executor käsittelee vaivatta valtavia tehtävämääriä. Jokainen tehtävä saa oman virtuaalisäikeensä.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    public static void main(String[] args) {
        AtomicInteger sum = new AtomicInteger();
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            for (int i = 1; i <= 1000; i++) {
                final int n = i;
                exec.submit(() -> sum.addAndGet(n));
            }
        }
        System.out.println("Sum 1..1000 = " + sum.get());
    }
}

Tulosten kerääminen Futuren avulla

submit palauttaa Future-olion, joten voitte kerätä palautusarvoja aivan kuten minkä tahansa executorin kanssa.

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        try (ExecutorService exec = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<Integer> f = exec.submit(() -> 6 * 7);
            System.out.println("Result: " + f.get());
        }
    }
}

Rakentaja vai executor

Valitkaa käyttötarkoituksen perusteella:

Builder / startVirtualThread yksittäisiä säikeitä tai mukautettuja nimiä varten
newVirtualThreadPerTaskExecutor tehtäväkokoelmien lähettämiseen ja tulosten keräämiseen

Kumpikin luo yhden virtuaalisäikeen työyksikköä kohden, juuri kuten pitääkin.

Älkää koskaan välimuistittako virtuaalisäikeiden executoria

Älkää käyttäkö yhtä virtuaalisäikeiden executoria uudelleen ikään kuin se olisi kiinteä työskentelysäikeiden pooli. Executorin voi kyllä käyttää uudelleen, mutta muistakaa, että jokainen tehtävä käynnistää täysin uuden säikeen.

Oleellista on, ettei säikeitä pooliteta, vaan ainoastaan tehtävien lähettämistä helpotetaan.

Pikatarkistus

Valitkaa paras tapa suorittaa suuri erä tehtäviä siten, että jokainen suoritetaan omassa virtuaalisäikeessään.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Nyt osaatte luoda virtuaalisäikeitä:

Thread.ofVirtual().start(...) ja .unstarted(...)
Thread.startVirtualThread(...)-yksirivinen kutsu
.factory() uudelleenkäytettävää ThreadFactory-tehdasta varten
Executors.newVirtualThreadPerTaskExecutor() try-with-resources-rakenteen kanssa

Seuraavaksi opitte valitsemaan alustasäikeiden ja virtuaalisäikeiden välillä.

Aloita maksutta

Opi Java tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 104
Oppitunnit: 374

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Virtuaalisäikeiden luonti” ilmainen?

Kyllä – oppitunnin ”Virtuaalisäikeiden luonti” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Java Academy-kurssin, päivitä CoddyKit PROhon. Java Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Virtuaalisäikeiden luonti”?

Thread.ofVirtual ja suorittimet. Harjoittelet Java Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Java Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Java Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Virtuaalisäikeiden luonti”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Java Academy-oppitunnilla?

Kyllä. Jokainen Java Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Java Academy