Java Academy · leksjon

ExecutorService og trådpooltyper

Opprett faste, hurtigbufrede, enkeltstående og tidsstyrte trådpooler, og forstå når hver av dem bør brukes.

Leksjon 1 av 413 trinn

ExecutorService og trådpooltyper er en gratis leksjon i Java Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Java Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hvorfor bruke trådpooler?

Det er kostbart å opprette en ny Thread for hver oppgave — oppretting og avslutning av tråder medfører ekstra kostnader. En trådpool gjenbruker et fast sett med tråder til å utføre mange oppgaver, noe som reduserer kostnadene og gir kontroll over ressursforbruket.

import java.util.concurrent.*;

// Bad practice: new thread per task
new Thread(() -> System.out.println("task")).start();

// Better: reuse threads from a pool
ExecutorService pool = Executors.newFixedThreadPool(4);
pool.submit(() -> System.out.println("task from pool"));
pool.shutdown();

newFixedThreadPool

Oppretter en pool med nøyaktig N tråder. Ekstra oppgaver legges i kø til en tråd blir ledig. Passer godt når De kjenner ønsket grad av parallellitet.

ExecutorService pool = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    final int taskId = i;
    pool.submit(() -> {
        System.out.println("Task " + taskId + " on " + Thread.currentThread().getName());
    });
}

pool.shutdown();
pool.awaitTermination(10, TimeUnit.SECONDS);

newCachedThreadPool

Oppretter tråder ved behov og gjenbruker ledige tråder. Tråder som er inaktive i 60 sekunder, avsluttes. Passer godt for mange kortvarige oppgaver, men er risikabelt for langvarige eller ubegrensede oppgaver fordi minnet kan bli brukt opp.

ExecutorService cached = Executors.newCachedThreadPool();

for (int i = 0; i < 100; i++) {
    cached.submit(() -> {
        // quick task
        double result = Math.sqrt(Math.random());
    });
}
cached.shutdown();

newSingleThreadExecutor

En pool med nøyaktig én tråd. Oppgavene utføres sekvensielt i innsendingsrekkefølgen. Passer godt for å serialisere tilgang til en delt ressurs.

ExecutorService single = Executors.newSingleThreadExecutor();

single.submit(() -> System.out.println("Task 1"));
single.submit(() -> System.out.println("Task 2"));
single.submit(() -> System.out.println("Task 3"));
// Always prints: Task 1, Task 2, Task 3 (sequential)
single.shutdown();

newScheduledThreadPool

Støtter planlagte og gjentakende oppgaver. Bruk den til polling, nye forsøk og vedlikeholdsoppgaver i bakgrunnen.

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

// One-shot delay
scheduler.schedule(() -> System.out.println("Delayed!"),
    3, TimeUnit.SECONDS);

// Fixed rate (every 2 seconds)
scheduler.scheduleAtFixedRate(
    () -> System.out.println("Tick"),
    0, 2, TimeUnit.SECONDS);

// Run later: scheduler.shutdown();

VirtualThreadExecutor (Java 21+)

Java 21 introduserer virtuelle tråder — tråder som er lette og billige å opprette. Bruk Executors.newVirtualThreadPerTaskExecutor() for arbeidsbelastninger som hovedsakelig utfører I/O:

// Java 21+
try (var exec = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        final int id = i;
        exec.submit(() -> {
            Thread.sleep(100); // blocks without tying up OS thread
            System.out.println("vthread " + id);
        });
    }
} // auto-shutdown

Velge riktig pool

Retningslinjer:

CPU-bundne oppgaver: Fast pool med N = antall CPU-kjerner
I/O-bundne oppgaver: Cached-pool eller virtuelle tråder
Sekvensielle oppgaver: Single thread executor
Planlagte eller gjentakende oppgaver: Scheduled thread pool

int cores = Runtime.getRuntime().availableProcessors();
ExecutorService cpuPool = Executors.newFixedThreadPool(cores);
System.out.println("Pool size: " + cores);

Tilpasset ThreadPoolExecutor

For detaljert kontroll kan De opprette en ThreadPoolExecutor direkte:

ThreadPoolExecutor tpe = new ThreadPoolExecutor(
    2,           // corePoolSize
    10,          // maximumPoolSize
    60L,         // keepAliveTime
    TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100), // work queue
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.CallerRunsPolicy() // rejection policy
);
tpe.submit(() -> System.out.println("Custom pool task"));
tpe.shutdown();

Kontrollert avslutning

Avslutt alltid ExecutorService for å frigjøre trådene. shutdown() slutter å godta nye oppgaver, men fullfører oppgavene som ligger i køen. shutdownNow() forsøker å avbryte oppgaver som kjører.

ExecutorService pool = Executors.newFixedThreadPool(4);
// ... submit tasks ...

pool.shutdown(); // no new tasks
try {
    if (!pool.awaitTermination(30, TimeUnit.SECONDS)) {
        pool.shutdownNow(); // force cancel
    }
} catch (InterruptedException e) {
    pool.shutdownNow();
    Thread.currentThread().interrupt();
}

ExecutorService som AutoCloseable (Java 19+)

I Java 19 og nyere implementerer ExecutorService AutoCloseable. Bruk try-with-resources for automatisk avslutning:

// Java 19+ (preview), Java 21 stable
try (ExecutorService pool = Executors.newFixedThreadPool(4)) {
    pool.submit(() -> System.out.println("task"));
} // pool.close() called: waits for tasks then shuts down

Avvisningsstrategier

Når poolen er full (alle trådene er opptatt og køen er full), håndterer avvisningsstrategien overskytende oppgaver:

AbortPolicy (standard): kaster RejectedExecutionException
CallerRunsPolicy: tråden som kaller, kjører oppgaven
DiscardPolicy: forkaster oppgaven uten varsel
DiscardOldestPolicy: forkaster den eldste oppgaven i køen

Kort kontrollspørsmål

De har en CPU-bundet oppgave som utfører omfattende beregninger. Hvor mange tråder bør den faste trådpoolen ha?

Besvar den i den interaktive leksjonen

Oppsummering: ExecutorService og trådpooler

Viktig å huske:

Fast pool: et fast antall N tråder; ekstra oppgaver legges i kø
Cached-pool: vokser ved behov; ledige tråder utløper etter 60 sekunder
Én tråd: rekkefølgen for sekvensiell utføring er garantert
Scheduled-pool: forsinkede og gjentakende oppgaver
Kall alltid shutdown(); bruk awaitTermination() for en kontrollert avslutning

Gratis å komme i gang

Lær deg Java med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 104
Leksjoner: 374

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «ExecutorService og trådpooltyper» gratis?

Ja – hele teksten i «ExecutorService og trådpooltyper» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Java Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Java Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «ExecutorService og trådpooltyper»?

Opprett faste, hurtigbufrede, enkeltstående og tidsstyrte trådpooler, og forstå når hver av dem bør brukes. Du øver på Java Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Java Academy?

Ingen tidligere erfaring er nødvendig. Java Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «ExecutorService og trådpooltyper»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Java Academy-leksjonen?

Ja. Alle Java Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

ExecutorService og trådpooltyper
Sende inn oppgaver: Runnable kontra Callable
Future og feilhåndtering
ScheduledExecutorService for gjentakende oppgaver

← Tilbake til Java Academy