KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / Java

Thread: starten, wachten op beëindiging en onderbreken

Maak platformthreads met Runnable-taken, start ze één keer, lees hun resultaten na join() en behoud de interruptstatus bij coöperatief annuleren.

Versie: Java SE 21

Syntax

new Thread(task);             // task: Runnable
new Thread(task, name);       // name: String
worker.start();               // void
worker.join();                // void; throws InterruptedException
worker.join(millis);          // long; same return and checked exception
worker.join(millis, nanos);   // long, int; same return and checked exception
worker.join(duration);        // java.time.Duration; boolean; throws InterruptedException
Thread.currentThread();       // static; returns Thread
worker.getName();             // returns String
worker.interrupt();           // request interruption of worker
Thread.currentThread().interrupt(); // set the calling thread's interrupt status

In Java SE 21 maken beide constructors van java.lang.Thread een nog niet gestarte platformthread, geen virtuele thread. Thread(Runnable) genereert een naam; Thread(Runnable,String) gebruikt de opgegeven naam. De statische methode Thread.currentThread() geeft de uitvoerende thread terug. De instantiemethode getName() geeft diens naam terug: een label, geen unieke identificatie.

worker.start() plant de taak in op de nieuwe thread. Een directe aanroep van worker.run() voert de taak uit op de aanroepende thread. Een tweede aanroep van start() gooit IllegalThreadStateException, ook nadat de thread is beëindigd. Door de happens-before-relatie zijn acties vóór start() zichtbaar voor de gestarte thread. De startvolgorde bepaalt de uitvoeringsvolgorde niet.

worker.join() laat de aanroeper wachten tot de gestarte worker eindigt; bij een niet-gestarte thread keert de methode meteen terug. Na normale terugkeer van join() voor een gestarte thread zijn de schrijfbewerkingen ervan zichtbaar voor de aanroeper. Wacht op alle threads die resultaten produceren voordat je die leest. Dit verhelpt geen dataraces tussen die threads en bewijst niet dat hun taken zijn geslaagd. join(long) en join(long,int) kunnen terugkeren zodra de wachttijd verstrijkt; alleen nullen als argumenten betekent geen tijdslimiet. join(Duration) meldt of de thread is beëindigd en gooit IllegalThreadStateException bij een niet-gestarte thread.

worker.interrupt() geeft de worker een onderbrekingssignaal, maar stopt hem niet gedwongen. Als join() of await() een InterruptedException gooit, wordt de interruptstatus van de aanroepende thread gewist. Geef de uitzondering zo mogelijk door. Ruim anders op, herstel de status met Thread.currentThread().interrupt() en beëindig het annuleringspad zonder succes te melden. isInterrupted() leest de status zonder die te wissen; het statische Thread.interrupted() leest en wist die van de huidige thread. Vertrouw er niet op dat onderbreken effect heeft bij een thread die niet leeft. In Java SE 21 kan een securitymanager onderbreking van een andere thread verbieden.

Voorbeelden

import java.util.concurrent.CountDownLatch;

public class ThreadMethodsDemo {
    public static void main(String[] args) throws InterruptedException {
        var gate = new CountDownLatch(1);
        var observations = new String[2];

        Thread compute = new Thread(() -> observations[0] = "sum=" + (20 + 22));
        Thread cancellable = new Thread(() -> {
            Thread self = Thread.currentThread();
            try {
                gate.await();
            } catch (InterruptedException e) {
                self.interrupt();
                observations[1] = self.getName() + ": cancelled; interrupted="
                        + self.isInterrupted();
                return;
            }
        }, "cancellable");

        compute.start();
        cancellable.start();
        cancellable.interrupt();
        compute.join();
        cancellable.join();

        System.out.println(observations[0]);
        System.out.println(observations[1]);
    }
}

Resultaat

sum=42
cancellable: cancelled; interrupted=true

De eerste thread slaat een som op; de thread met de opgegeven naam registreert annulering. De poort blijft dicht, dus `await()` reageert op onderbreking vóór of tijdens het wachten. Alleen `main` drukt de resultaten af, na beide `join()`-aanroepen. De regelvolgorde hangt dus niet af van de planning.

Gerelateerde lessen

  • Java · Les 25 · Gevorderd · Versie: 2
  • Java · Les 28 · Gevorderd · Versie: 2
  • Java · Les 30 · Gevorderd · Versie: 2
  • Java · Les 33 · Gevorderd · Versie: 2
  • Java · Les 34 · Gevorderd · Versie: 2
  • Java · Les 35 · Gevorderd · Versie: 2
  • Java · Les 36 · Gevorderd · Versie: 2
  • Java · Les 37 · Gevorderd · Versie: 2
  • Java · Les 38 · Gevorderd · Versie: 2

Bronnen